@genesislcap/ts-builder 14.417.0 → 14.417.1-alpha-efccb2a.0

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;yBAGrC,KAAK,YAAY;AAAvC,wBA2CE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;yBAIrC,KAAK,YAAY;AAAvC,wBAkDE"}

package/dist/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const build_kit_1 = require("@genesislcap/build-kit");
 const consola_1 = tslib_1.__importDefault(require("consola"));
+const react_jsx_generator_1 = require("./react-jsx-generator");
 exports.default = (ctx) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
     const { dirs: { cwd }, cli: { isDev, isBuild, options }, config: { clean, copyAssets }, enable: { apiExtractor, cemAnalyzer }, } = ctx;
     if (clean) {
@@ -34,6 +35,13 @@ exports.default = (ctx) => tslib_1.__awaiter(void 0, void 0, void 0, function* (
             const cem = yield (0, build_kit_1.resolveBin)('cem', '@custom-elements-manifest/analyzer');
             (0, build_kit_1.run)(cwd, `${cem} analyze --config custom-elements-manifest.config.*js`);
         }
+        const reactTypesResult = yield (0, react_jsx_generator_1.generateReactJsxTypes)(cwd);
+        if (reactTypesResult.generated) {
+            consola_1.default.log(`\nReact JSX types generated: ${reactTypesResult.path}`);
+        }
+        else {
+            consola_1.default.debug(`React JSX types were skipped: ${reactTypesResult.reason}`);
+        }
     }
     else {
         throw new Error(`Unrecognized command: ${JSON.stringify(options)}`);

package/dist/react-jsx-generator.d.ts

@@ -0,0 +1,6 @@
+export declare function generateReactJsxTypes(cwd: string): Promise<{
+    generated: boolean;
+    path?: string;
+    reason?: string;
+}>;
+//# sourceMappingURL=react-jsx-generator.d.ts.map

package/dist/react-jsx-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-jsx-generator.d.ts","sourceRoot":"","sources":["../src/react-jsx-generator.ts"],"names":[],"mappings":"AAgZA,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAoCjE"}

package/dist/react-jsx-generator.js

@@ -0,0 +1,374 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateReactJsxTypes = generateReactJsxTypes;
+const tslib_1 = require("tslib");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const GENERATED_FILE_NAME = 'react-jsx-runtime.d.ts';
+const primitiveUnionRegex = /^(?:\s*(?:string|number|boolean|bigint|null|undefined|unknown|any|void|'[^']*'|"[^"]*"|`[^`]*`|(?:\d+(?:\.\d+)?))\s*)(?:\|\s*(?:string|number|boolean|bigint|null|undefined|unknown|any|void|'[^']*'|"[^"]*"|`[^`]*`|(?:\d+(?:\.\d+)?))\s*)*$/;
+const allowedTypeIdentifierRegex = /^[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/;
+const allowedTypeNameSet = new Set([
+    'Array',
+    'ReadonlyArray',
+    'Promise',
+    'Record',
+    'Partial',
+    'Required',
+    'Pick',
+    'Omit',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Date',
+    'RegExp',
+    'Error',
+    'Node',
+    'Element',
+    'HTMLElement',
+    'SVGElement',
+    'Event',
+    'CustomEvent',
+    'MouseEvent',
+    'KeyboardEvent',
+    'FocusEvent',
+    'InputEvent',
+    'PointerEvent',
+    'WheelEvent',
+    'DragEvent',
+    'SubmitEvent',
+    'AbortSignal',
+    'DOMRect',
+    'Document',
+    'Window',
+    'URL',
+    'URLSearchParams',
+    'CSSStyleDeclaration',
+    'Intl.Locale',
+]);
+function normalizeWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function toTypeNameSegment(value) {
+    const pascal = toPascalCase(value);
+    if (!pascal) {
+        return 'Pkg';
+    }
+    if (/^[0-9]/.test(pascal)) {
+        return `Pkg${pascal}`;
+    }
+    return pascal;
+}
+function getPackageTypePrefix(packageName) {
+    const withoutScope = packageName.replace(/^@/, '').replace(/\//g, '-');
+    const segment = toTypeNameSegment(withoutScope);
+    return `${segment}React`;
+}
+function normalizePropertyName(name) {
+    let normalized = name.trim();
+    if (!normalized)
+        return null;
+    const bracketQuotedMatch = normalized.match(/^\[\s*['"](.+?)['"]\s*\]$/);
+    if (bracketQuotedMatch) {
+        normalized = bracketQuotedMatch[1];
+    }
+    else {
+        const bracketMatch = normalized.match(/^\[\s*(.+?)\s*\]$/);
+        if (bracketMatch) {
+            normalized = bracketMatch[1];
+        }
+        const quotedMatch = normalized.match(/^['"](.+?)['"]$/);
+        if (quotedMatch) {
+            normalized = quotedMatch[1];
+        }
+    }
+    normalized = normalized.trim();
+    if (!normalized)
+        return null;
+    if (normalized.includes('\n') || normalized.includes('\r'))
+        return null;
+    return normalized;
+}
+function escapeSingleQuotes(value) {
+    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+function isKnownTypeIdentifier(identifier) {
+    if (allowedTypeNameSet.has(identifier))
+        return true;
+    if (allowedTypeIdentifierRegex.test(identifier) && identifier.startsWith('globalThis.'))
+        return true;
+    return false;
+}
+function canUseComplexType(typeText) {
+    var _a;
+    if (!typeText)
+        return false;
+    if (/[{};=]/.test(typeText))
+        return false;
+    if (/=>/.test(typeText))
+        return false;
+    if (!/^[A-Za-z0-9_$<>\[\]\(\)\|&,.?'"`\s:-]+$/.test(typeText))
+        return false;
+    const identifierMatches = (_a = typeText.match(/[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*/g)) !== null && _a !== void 0 ? _a : [];
+    for (const match of identifierMatches) {
+        if (match === 'true' ||
+            match === 'false' ||
+            match === 'null' ||
+            match === 'undefined' ||
+            match === 'string' ||
+            match === 'number' ||
+            match === 'boolean' ||
+            match === 'bigint' ||
+            match === 'symbol' ||
+            match === 'unknown' ||
+            match === 'any' ||
+            match === 'void' ||
+            match === 'never') {
+            continue;
+        }
+        if (!isKnownTypeIdentifier(match)) {
+            return false;
+        }
+    }
+    return true;
+}
+function toPascalCase(value) {
+    return value
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map((part) => `${part[0].toUpperCase()}${part.slice(1)}`)
+        .join('');
+}
+function toCamelCase(value) {
+    const pascal = toPascalCase(value);
+    if (!pascal)
+        return '';
+    return `${pascal[0].toLowerCase()}${pascal.slice(1)}`;
+}
+function toSafeType(typeText) {
+    if (!typeText)
+        return 'unknown';
+    const normalized = normalizeWhitespace(typeText);
+    if (!normalized)
+        return 'unknown';
+    if (primitiveUnionRegex.test(normalized)) {
+        return normalized;
+    }
+    if (normalized.endsWith('[]')) {
+        const itemType = normalized.slice(0, -2).trim();
+        if (primitiveUnionRegex.test(itemType)) {
+            return `${itemType}[]`;
+        }
+    }
+    if (canUseComplexType(normalized)) {
+        return normalized;
+    }
+    return 'unknown';
+}
+function getCEMManifestPath(cwd, packageJson) {
+    if (typeof packageJson.customElements === 'string' && packageJson.customElements.trim().length > 0) {
+        return (0, node_path_1.resolve)(cwd, packageJson.customElements);
+    }
+    return (0, node_path_1.resolve)(cwd, 'dist/custom-elements.json');
+}
+function collectCustomElements(manifest) {
+    var _a, _b;
+    const elements = [];
+    for (const moduleDefinition of (_a = manifest.modules) !== null && _a !== void 0 ? _a : []) {
+        for (const declaration of (_b = moduleDefinition.declarations) !== null && _b !== void 0 ? _b : []) {
+            if (declaration.customElement && declaration.tagName) {
+                elements.push(declaration);
+            }
+        }
+    }
+    return elements;
+}
+function normalizeTagNames(tagName) {
+    const prefixToken = '%%prefix%%-';
+    if (!tagName.includes(prefixToken)) {
+        return [tagName];
+    }
+    const suffix = tagName.replace(prefixToken, '');
+    return [`rapid-${suffix}`, `zero-${suffix}`];
+}
+function toEventHandlerType(typeText) {
+    var _a;
+    if (!typeText) {
+        return '(event: CustomEvent<unknown>) => void';
+    }
+    const normalized = typeText.trim();
+    if (!normalized) {
+        return '(event: CustomEvent<unknown>) => void';
+    }
+    if (normalized === 'Event') {
+        return '(event: Event) => void';
+    }
+    if (normalized.startsWith('CustomEvent<')) {
+        const match = normalized.match(/^CustomEvent<(.+)>$/);
+        if (!match)
+            return '(event: CustomEvent<unknown>) => void';
+        const detailType = toSafeType((_a = match[1]) === null || _a === void 0 ? void 0 : _a.trim());
+        return `(event: CustomEvent<${detailType}>) => void`;
+    }
+    if (normalized === 'CustomEvent') {
+        return '(event: CustomEvent<unknown>) => void';
+    }
+    return '(event: CustomEvent<unknown>) => void';
+}
+function buildElementProps(declaration) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const propertyMap = new Map();
+    const eventMap = new Map();
+    const addProperty = (name, typeText) => {
+        if (!name)
+            return;
+        const normalizedName = normalizePropertyName(name);
+        if (!normalizedName)
+            return;
+        const safeType = toSafeType(typeText);
+        if (!propertyMap.has(normalizedName)) {
+            propertyMap.set(normalizedName, safeType);
+        }
+    };
+    for (const attribute of (_a = declaration.attributes) !== null && _a !== void 0 ? _a : []) {
+        // Prefer React-friendly property casing when available.
+        if (attribute.fieldName) {
+            addProperty(attribute.fieldName, (_b = attribute.type) === null || _b === void 0 ? void 0 : _b.text);
+        }
+        else if (attribute.name) {
+            addProperty(attribute.name, (_c = attribute.type) === null || _c === void 0 ? void 0 : _c.text);
+            if (attribute.name.includes('-')) {
+                const camelName = toCamelCase(attribute.name);
+                if (camelName) {
+                    addProperty(camelName, (_d = attribute.type) === null || _d === void 0 ? void 0 : _d.text);
+                }
+            }
+        }
+    }
+    // Only include public fields that are reflected as attributes.
+    for (const member of (_e = declaration.members) !== null && _e !== void 0 ? _e : []) {
+        if (member.kind === 'field' &&
+            member.privacy !== 'private' &&
+            member.privacy !== 'protected' &&
+            member.attribute &&
+            member.name &&
+            !member.name.startsWith('_') &&
+            !member.name.startsWith('$')) {
+            // React canonical typing should expose property name (camelCase).
+            addProperty(member.name, (_f = member.type) === null || _f === void 0 ? void 0 : _f.text);
+        }
+    }
+    for (const event of (_g = declaration.events) !== null && _g !== void 0 ? _g : []) {
+        if (!event.name)
+            continue;
+        const normalizedEventName = normalizePropertyName(event.name);
+        if (!normalizedEventName)
+            continue;
+        const eventHandlerType = toEventHandlerType((_h = event.type) === null || _h === void 0 ? void 0 : _h.text);
+        const pascalName = toPascalCase(normalizedEventName);
+        if (pascalName) {
+            eventMap.set(`on${pascalName}`, eventHandlerType);
+        }
+    }
+    const lines = [
+        'children?: unknown;',
+        'class?: string;',
+        'className?: string;',
+        'id?: string;',
+        'slot?: string;',
+        'part?: string;',
+        'style?: string | Partial<CSSStyleDeclaration>;',
+        'role?: string;',
+        'tabIndex?: number | string;',
+        '[key: `data-${string}`]: string | number | boolean | undefined;',
+        '[key: `aria-${string}`]: string | number | boolean | undefined;',
+    ];
+    for (const [name, typeText] of propertyMap) {
+        lines.push(`'${escapeSingleQuotes(name)}'?: ${typeText};`);
+    }
+    for (const [name, handlerType] of eventMap) {
+        lines.push(`'${escapeSingleQuotes(name)}'?: ${handlerType};`);
+    }
+    return lines;
+}
+function generateDeclarations(packageName, declarations) {
+    const packagePrefix = getPackageTypePrefix(packageName);
+    const interfacesByTag = new Map();
+    let interfaceCounter = 0;
+    for (const declaration of declarations) {
+        const interfaceName = `${packagePrefix}ElementProps${interfaceCounter + 1}`;
+        interfaceCounter += 1;
+        const props = buildElementProps(declaration).map((line) => `    ${line}`);
+        const code = [`  interface ${interfaceName} {`, ...props, '  }'].join('\n');
+        for (const tagName of normalizeTagNames(declaration.tagName)) {
+            if (!interfacesByTag.has(tagName)) {
+                interfacesByTag.set(tagName, { interfaceName, code, tagName });
+            }
+        }
+    }
+    const elementInterfaces = [...interfacesByTag.values()].sort((a, b) => a.tagName.localeCompare(b.tagName));
+    const intrinsicEntries = elementInterfaces.map((entry) => `      '${entry.tagName}': ${entry.interfaceName};`);
+    return [
+        '/**',
+        ' * AUTO-GENERATED FILE - DO NOT EDIT.',
+        ` * Source package: ${packageName}`,
+        ' * Generated from custom-elements manifest.',
+        ' */',
+        '',
+        "declare module 'react/jsx-runtime' {",
+        '  namespace JSX {',
+        ...elementInterfaces.map((entry) => entry.code),
+        '    interface IntrinsicElements {',
+        ...intrinsicEntries,
+        '    }',
+        '  }',
+        '}',
+        '',
+        'export {};',
+        '',
+    ].join('\n');
+}
+function fileExists(path) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            yield (0, promises_1.stat)(path);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+function generateReactJsxTypes(cwd) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const packageJsonPath = (0, node_path_1.resolve)(cwd, 'package.json');
+        if (!(yield fileExists(packageJsonPath))) {
+            return { generated: false, reason: 'No package.json found.' };
+        }
+        const packageJson = JSON.parse(yield (0, promises_1.readFile)(packageJsonPath, 'utf8'));
+        const manifestPath = getCEMManifestPath(cwd, packageJson);
+        if (!(yield fileExists(manifestPath))) {
+            return { generated: false, reason: 'No custom elements manifest found.' };
+        }
+        const manifest = JSON.parse(yield (0, promises_1.readFile)(manifestPath, 'utf8'));
+        const declarations = collectCustomElements(manifest);
+        if (!declarations.length) {
+            return { generated: false, reason: 'No custom elements discovered in manifest.' };
+        }
+        const dtsRoot = (0, node_path_1.resolve)(cwd, 'dist/dts');
+        const outputPath = (0, node_path_1.resolve)(dtsRoot, GENERATED_FILE_NAME);
+        yield (0, promises_1.mkdir)((0, node_path_1.dirname)(outputPath), { recursive: true });
+        const packageName = typeof packageJson.name === 'string' ? packageJson.name : 'unknown-package';
+        const content = generateDeclarations(packageName, declarations);
+        yield (0, promises_1.writeFile)(outputPath, content, 'utf8');
+        const rootTypesPath = (0, node_path_1.resolve)(cwd, 'dist/dts/index.d.ts');
+        if (yield fileExists(rootTypesPath)) {
+            const indexTypes = yield (0, promises_1.readFile)(rootTypesPath, 'utf8');
+            const referenceLine = `/// <reference path="./${GENERATED_FILE_NAME}" />`;
+            if (!indexTypes.includes(referenceLine)) {
+                yield (0, promises_1.writeFile)(rootTypesPath, `${referenceLine}\n${indexTypes}`, 'utf8');
+            }
+        }
+        return { generated: true, path: outputPath };
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ts-builder",
   "description": "Typescript builder",
-  "version": "14.417.0",
+  "version": "14.417.1-alpha-efccb2a.0",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@custom-elements-manifest/analyzer": "^0.8.2",
-    "@genesislcap/build-kit": "14.417.0",
+    "@genesislcap/build-kit": "14.417.1-alpha-efccb2a.0",
     "consola": "^3.0.2",
     "copyfiles": "^2.4.1",
     "pkg-types": "^1.0.2"
@@ -30,5 +30,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "1a4b13faca04aa12b0a8bd6032a798369fe7eb33"
+  "gitHead": "00d0d357de82849ea9dc574f615ba69d71b78ede"
 }

package/src/index.ts

@@ -1,6 +1,7 @@
 import { rm, run, resolveBin } from '@genesislcap/build-kit';
 import type { BuildContext } from '@genesislcap/build-kit';
 import consola from 'consola';
+import { generateReactJsxTypes } from './react-jsx-generator';
 
 export default async (ctx: BuildContext) => {
   const {
@@ -42,6 +43,13 @@ export default async (ctx: BuildContext) => {
       const cem = await resolveBin('cem', '@custom-elements-manifest/analyzer');
       run(cwd, `${cem} analyze --config custom-elements-manifest.config.*js`);
     }
+
+    const reactTypesResult = await generateReactJsxTypes(cwd);
+    if (reactTypesResult.generated) {
+      consola.log(`\nReact JSX types generated: ${reactTypesResult.path}`);
+    } else {
+      consola.debug(`React JSX types were skipped: ${reactTypesResult.reason}`);
+    }
   } else {
     throw new Error(`Unrecognized command: ${JSON.stringify(options)}`);
   }

package/src/react-jsx-generator.ts

@@ -0,0 +1,439 @@
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+
+type CEMType = { text?: string };
+type CEMEvent = { name?: string; type?: CEMType };
+type CEMMember = {
+  name?: string;
+  fieldName?: string;
+  attribute?: string | null;
+  kind?: string;
+  privacy?: string;
+  type?: CEMType;
+};
+type CEMDeclaration = {
+  customElement?: boolean;
+  tagName?: string;
+  members?: CEMMember[];
+  attributes?: CEMMember[];
+  events?: CEMEvent[];
+};
+type CEMModule = {
+  declarations?: CEMDeclaration[];
+};
+type CEMManifest = {
+  modules?: CEMModule[];
+};
+
+const GENERATED_FILE_NAME = 'react-jsx-runtime.d.ts';
+
+const primitiveUnionRegex =
+  /^(?:\s*(?:string|number|boolean|bigint|null|undefined|unknown|any|void|'[^']*'|"[^"]*"|`[^`]*`|(?:\d+(?:\.\d+)?))\s*)(?:\|\s*(?:string|number|boolean|bigint|null|undefined|unknown|any|void|'[^']*'|"[^"]*"|`[^`]*`|(?:\d+(?:\.\d+)?))\s*)*$/;
+
+const allowedTypeIdentifierRegex = /^[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*$/;
+const allowedTypeNameSet = new Set([
+  'Array',
+  'ReadonlyArray',
+  'Promise',
+  'Record',
+  'Partial',
+  'Required',
+  'Pick',
+  'Omit',
+  'Map',
+  'Set',
+  'WeakMap',
+  'WeakSet',
+  'Date',
+  'RegExp',
+  'Error',
+  'Node',
+  'Element',
+  'HTMLElement',
+  'SVGElement',
+  'Event',
+  'CustomEvent',
+  'MouseEvent',
+  'KeyboardEvent',
+  'FocusEvent',
+  'InputEvent',
+  'PointerEvent',
+  'WheelEvent',
+  'DragEvent',
+  'SubmitEvent',
+  'AbortSignal',
+  'DOMRect',
+  'Document',
+  'Window',
+  'URL',
+  'URLSearchParams',
+  'CSSStyleDeclaration',
+  'Intl.Locale',
+]);
+
+function normalizeWhitespace(value: string): string {
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+function toTypeNameSegment(value: string): string {
+  const pascal = toPascalCase(value);
+  if (!pascal) {
+    return 'Pkg';
+  }
+
+  if (/^[0-9]/.test(pascal)) {
+    return `Pkg${pascal}`;
+  }
+
+  return pascal;
+}
+
+function getPackageTypePrefix(packageName: string): string {
+  const withoutScope = packageName.replace(/^@/, '').replace(/\//g, '-');
+  const segment = toTypeNameSegment(withoutScope);
+  return `${segment}React`;
+}
+
+function normalizePropertyName(name: string): string | null {
+  let normalized = name.trim();
+  if (!normalized) return null;
+
+  const bracketQuotedMatch = normalized.match(/^\[\s*['"](.+?)['"]\s*\]$/);
+  if (bracketQuotedMatch) {
+    normalized = bracketQuotedMatch[1];
+  } else {
+    const bracketMatch = normalized.match(/^\[\s*(.+?)\s*\]$/);
+    if (bracketMatch) {
+      normalized = bracketMatch[1];
+    }
+    const quotedMatch = normalized.match(/^['"](.+?)['"]$/);
+    if (quotedMatch) {
+      normalized = quotedMatch[1];
+    }
+  }
+
+  normalized = normalized.trim();
+  if (!normalized) return null;
+  if (normalized.includes('\n') || normalized.includes('\r')) return null;
+  return normalized;
+}
+
+function escapeSingleQuotes(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+
+function isKnownTypeIdentifier(identifier: string): boolean {
+  if (allowedTypeNameSet.has(identifier)) return true;
+  if (allowedTypeIdentifierRegex.test(identifier) && identifier.startsWith('globalThis.')) return true;
+  return false;
+}
+
+function canUseComplexType(typeText: string): boolean {
+  if (!typeText) return false;
+  if (/[{};=]/.test(typeText)) return false;
+  if (/=>/.test(typeText)) return false;
+  if (!/^[A-Za-z0-9_$<>\[\]\(\)\|&,.?'"`\s:-]+$/.test(typeText)) return false;
+
+  const identifierMatches = typeText.match(/[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*/g) ?? [];
+  for (const match of identifierMatches) {
+    if (
+      match === 'true' ||
+      match === 'false' ||
+      match === 'null' ||
+      match === 'undefined' ||
+      match === 'string' ||
+      match === 'number' ||
+      match === 'boolean' ||
+      match === 'bigint' ||
+      match === 'symbol' ||
+      match === 'unknown' ||
+      match === 'any' ||
+      match === 'void' ||
+      match === 'never'
+    ) {
+      continue;
+    }
+
+    if (!isKnownTypeIdentifier(match)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function toPascalCase(value: string): string {
+  return value
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean)
+    .map((part) => `${part[0].toUpperCase()}${part.slice(1)}`)
+    .join('');
+}
+
+function toCamelCase(value: string): string {
+  const pascal = toPascalCase(value);
+  if (!pascal) return '';
+  return `${pascal[0].toLowerCase()}${pascal.slice(1)}`;
+}
+
+function toSafeType(typeText?: string): string {
+  if (!typeText) return 'unknown';
+  const normalized = normalizeWhitespace(typeText);
+  if (!normalized) return 'unknown';
+
+  if (primitiveUnionRegex.test(normalized)) {
+    return normalized;
+  }
+
+  if (normalized.endsWith('[]')) {
+    const itemType = normalized.slice(0, -2).trim();
+    if (primitiveUnionRegex.test(itemType)) {
+      return `${itemType}[]`;
+    }
+  }
+
+  if (canUseComplexType(normalized)) {
+    return normalized;
+  }
+
+  return 'unknown';
+}
+
+function getCEMManifestPath(cwd: string, packageJson: Record<string, unknown>): string {
+  if (typeof packageJson.customElements === 'string' && packageJson.customElements.trim().length > 0) {
+    return resolve(cwd, packageJson.customElements);
+  }
+
+  return resolve(cwd, 'dist/custom-elements.json');
+}
+
+function collectCustomElements(manifest: CEMManifest): CEMDeclaration[] {
+  const elements: CEMDeclaration[] = [];
+
+  for (const moduleDefinition of manifest.modules ?? []) {
+    for (const declaration of moduleDefinition.declarations ?? []) {
+      if (declaration.customElement && declaration.tagName) {
+        elements.push(declaration);
+      }
+    }
+  }
+
+  return elements;
+}
+
+function normalizeTagNames(tagName: string): string[] {
+  const prefixToken = '%%prefix%%-';
+  if (!tagName.includes(prefixToken)) {
+    return [tagName];
+  }
+
+  const suffix = tagName.replace(prefixToken, '');
+  return [`rapid-${suffix}`, `zero-${suffix}`];
+}
+
+function toEventHandlerType(typeText?: string): string {
+  if (!typeText) {
+    return '(event: CustomEvent<unknown>) => void';
+  }
+
+  const normalized = typeText.trim();
+  if (!normalized) {
+    return '(event: CustomEvent<unknown>) => void';
+  }
+
+  if (normalized === 'Event') {
+    return '(event: Event) => void';
+  }
+
+  if (normalized.startsWith('CustomEvent<')) {
+    const match = normalized.match(/^CustomEvent<(.+)>$/);
+    if (!match) return '(event: CustomEvent<unknown>) => void';
+    const detailType = toSafeType(match[1]?.trim());
+    return `(event: CustomEvent<${detailType}>) => void`;
+  }
+
+  if (normalized === 'CustomEvent') {
+    return '(event: CustomEvent<unknown>) => void';
+  }
+
+  return '(event: CustomEvent<unknown>) => void';
+}
+
+function buildElementProps(declaration: CEMDeclaration): string[] {
+  const propertyMap = new Map<string, string>();
+  const eventMap = new Map<string, string>();
+
+  const addProperty = (name: string, typeText?: string) => {
+    if (!name) return;
+    const normalizedName = normalizePropertyName(name);
+    if (!normalizedName) return;
+    const safeType = toSafeType(typeText);
+    if (!propertyMap.has(normalizedName)) {
+      propertyMap.set(normalizedName, safeType);
+    }
+  };
+
+  for (const attribute of declaration.attributes ?? []) {
+    // Prefer React-friendly property casing when available.
+    if (attribute.fieldName) {
+      addProperty(attribute.fieldName, attribute.type?.text);
+    } else if (attribute.name) {
+      addProperty(attribute.name, attribute.type?.text);
+      if (attribute.name.includes('-')) {
+        const camelName = toCamelCase(attribute.name);
+        if (camelName) {
+          addProperty(camelName, attribute.type?.text);
+        }
+      }
+    }
+  }
+
+  // Only include public fields that are reflected as attributes.
+  for (const member of declaration.members ?? []) {
+    if (
+      member.kind === 'field' &&
+      member.privacy !== 'private' &&
+      member.privacy !== 'protected' &&
+      member.attribute &&
+      member.name &&
+      !member.name.startsWith('_') &&
+      !member.name.startsWith('$')
+    ) {
+      // React canonical typing should expose property name (camelCase).
+      addProperty(member.name, member.type?.text);
+    }
+  }
+
+  for (const event of declaration.events ?? []) {
+    if (!event.name) continue;
+    const normalizedEventName = normalizePropertyName(event.name);
+    if (!normalizedEventName) continue;
+    const eventHandlerType = toEventHandlerType(event.type?.text);
+    const pascalName = toPascalCase(normalizedEventName);
+    if (pascalName) {
+      eventMap.set(`on${pascalName}`, eventHandlerType);
+    }
+  }
+
+  const lines: string[] = [
+    'children?: unknown;',
+    'class?: string;',
+    'className?: string;',
+    'id?: string;',
+    'slot?: string;',
+    'part?: string;',
+    'style?: string | Partial<CSSStyleDeclaration>;',
+    'role?: string;',
+    'tabIndex?: number | string;',
+    '[key: `data-${string}`]: string | number | boolean | undefined;',
+    '[key: `aria-${string}`]: string | number | boolean | undefined;',
+  ];
+
+  for (const [name, typeText] of propertyMap) {
+    lines.push(`'${escapeSingleQuotes(name)}'?: ${typeText};`);
+  }
+
+  for (const [name, handlerType] of eventMap) {
+    lines.push(`'${escapeSingleQuotes(name)}'?: ${handlerType};`);
+  }
+
+  return lines;
+}
+
+function generateDeclarations(packageName: string, declarations: CEMDeclaration[]): string {
+  const packagePrefix = getPackageTypePrefix(packageName);
+  const interfacesByTag = new Map<
+    string,
+    { interfaceName: string; code: string; tagName: string }
+  >();
+  let interfaceCounter = 0;
+
+  for (const declaration of declarations) {
+    const interfaceName = `${packagePrefix}ElementProps${interfaceCounter + 1}`;
+    interfaceCounter += 1;
+    const props = buildElementProps(declaration).map((line) => `    ${line}`);
+    const code = [`  interface ${interfaceName} {`, ...props, '  }'].join('\n');
+    for (const tagName of normalizeTagNames(declaration.tagName!)) {
+      if (!interfacesByTag.has(tagName)) {
+        interfacesByTag.set(tagName, { interfaceName, code, tagName });
+      }
+    }
+  }
+
+  const elementInterfaces = [...interfacesByTag.values()].sort((a, b) =>
+    a.tagName.localeCompare(b.tagName),
+  );
+
+  const intrinsicEntries = elementInterfaces.map(
+    (entry) => `      '${entry.tagName}': ${entry.interfaceName};`,
+  );
+
+  return [
+    '/**',
+    ' * AUTO-GENERATED FILE - DO NOT EDIT.',
+    ` * Source package: ${packageName}`,
+    ' * Generated from custom-elements manifest.',
+    ' */',
+    '',
+    "declare module 'react/jsx-runtime' {",
+    '  namespace JSX {',
+    ...elementInterfaces.map((entry) => entry.code),
+    '    interface IntrinsicElements {',
+    ...intrinsicEntries,
+    '    }',
+    '  }',
+    '}',
+    '',
+    'export {};',
+    '',
+  ].join('\n');
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function generateReactJsxTypes(
+  cwd: string,
+): Promise<{ generated: boolean; path?: string; reason?: string }> {
+  const packageJsonPath = resolve(cwd, 'package.json');
+  if (!(await fileExists(packageJsonPath))) {
+    return { generated: false, reason: 'No package.json found.' };
+  }
+
+  const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8')) as Record<string, unknown>;
+  const manifestPath = getCEMManifestPath(cwd, packageJson);
+  if (!(await fileExists(manifestPath))) {
+    return { generated: false, reason: 'No custom elements manifest found.' };
+  }
+
+  const manifest = JSON.parse(await readFile(manifestPath, 'utf8')) as CEMManifest;
+  const declarations = collectCustomElements(manifest);
+  if (!declarations.length) {
+    return { generated: false, reason: 'No custom elements discovered in manifest.' };
+  }
+
+  const dtsRoot = resolve(cwd, 'dist/dts');
+  const outputPath = resolve(dtsRoot, GENERATED_FILE_NAME);
+  await mkdir(dirname(outputPath), { recursive: true });
+
+  const packageName = typeof packageJson.name === 'string' ? packageJson.name : 'unknown-package';
+  const content = generateDeclarations(packageName, declarations);
+  await writeFile(outputPath, content, 'utf8');
+
+  const rootTypesPath = resolve(cwd, 'dist/dts/index.d.ts');
+  if (await fileExists(rootTypesPath)) {
+    const indexTypes = await readFile(rootTypesPath, 'utf8');
+    const referenceLine = `/// <reference path="./${GENERATED_FILE_NAME}" />`;
+    if (!indexTypes.includes(referenceLine)) {
+      await writeFile(rootTypesPath, `${referenceLine}\n${indexTypes}`, 'utf8');
+    }
+  }
+
+  return { generated: true, path: outputPath };
+}

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/index.ts"],"version":"5.9.2"}
+{"root":["./src/index.ts","./src/react-jsx-generator.ts"],"version":"5.9.2"}