@genesislcap/ts-builder 14.418.2 → 14.419.1

package/dist/react-wrapper-generator.js

@@ -0,0 +1,704 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateReactWrappers = generateReactWrappers;
+const tslib_1 = require("tslib");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+// ── Constants ────────────────────────────────────────────────────────────────
+const PRIMITIVE_UNION_REGEX = /^(?:\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 IDENTIFIER_TOKEN_REGEX = /[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*/g;
+const PRIMITIVE_TOKENS = new Set([
+    'true', 'false', 'null', 'undefined', 'string', 'number', 'boolean',
+    'bigint', 'symbol', 'unknown', 'any', 'void', 'never',
+]);
+const KNOWN_TYPE_NAMES = 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',
+]);
+/**
+ * DOM event classes that map directly to `(event: T) => void`.
+ * Excludes bare `CustomEvent` which needs special handling for its detail type.
+ */
+const DOM_EVENT_CLASS_NAMES = new Set([
+    'Event', 'MouseEvent', 'KeyboardEvent', 'FocusEvent', 'InputEvent',
+    'PointerEvent', 'WheelEvent', 'DragEvent', 'SubmitEvent',
+]);
+/**
+ * React DOM reserves these `on*` prop names for native/synthetic events. When a CEM event
+ * name maps to the same handler (e.g. `click` → `onClick`), we must not emit a duplicate
+ * wrapper prop or it clashes with React's built-in typings.
+ *
+ * Resolved at startup from the consumer project's `@types/react/index.d.ts` so the set stays
+ * current without manual maintenance. Falls back to a static snapshot when `@types/react` is
+ * not installed (e.g. JS-only consumers — in that case the exclusion set is irrelevant anyway).
+ */
+function loadReactEventHandlerNames() {
+    try {
+        const typesPath = require.resolve('@types/react/index.d.ts');
+        const content = (0, node_fs_1.readFileSync)(typesPath, 'utf-8');
+        const names = new Set();
+        for (const m of content.matchAll(/\b(on[A-Z][a-zA-Z]+)\??\s*:/g)) {
+            names.add(m[1]);
+        }
+        if (names.size > 20)
+            return names;
+    }
+    catch (_a) { }
+    // Static snapshot — kept as fallback only.
+    return new Set([
+        'onCopy', 'onCut', 'onPaste', 'onCompositionEnd', 'onCompositionStart', 'onCompositionUpdate',
+        'onFocus', 'onBlur', 'onChange', 'onBeforeInput', 'onInput', 'onReset', 'onSubmit',
+        'onInvalid', 'onLoad', 'onError', 'onKeyDown', 'onKeyPress', 'onKeyUp', 'onAbort',
+        'onCanPlay', 'onCanPlayThrough', 'onDurationChange', 'onEmptied', 'onEncrypted', 'onEnded',
+        'onLoadedData', 'onLoadedMetadata', 'onLoadStart', 'onPause', 'onPlay', 'onPlaying',
+        'onProgress', 'onRateChange', 'onResize', 'onSeeked', 'onSeeking', 'onStalled', 'onSuspend',
+        'onTimeUpdate', 'onVolumeChange', 'onWaiting', 'onAuxClick', 'onClick', 'onContextMenu',
+        'onDoubleClick', 'onDrag', 'onDragEnd', 'onDragEnter', 'onDragExit', 'onDragLeave',
+        'onDragOver', 'onDragStart', 'onDrop', 'onMouseDown', 'onMouseEnter', 'onMouseLeave',
+        'onMouseMove', 'onMouseOut', 'onMouseOver', 'onMouseUp', 'onSelect', 'onTouchCancel',
+        'onTouchEnd', 'onTouchMove', 'onTouchStart', 'onPointerOver', 'onPointerEnter',
+        'onPointerDown', 'onPointerMove', 'onPointerUp', 'onPointerCancel', 'onPointerOut',
+        'onPointerLeave', 'onGotPointerCapture', 'onLostPointerCapture', 'onScroll', 'onWheel',
+        'onAnimationStart', 'onAnimationEnd', 'onAnimationIteration', 'onTransitionEnd', 'onToggle',
+    ]);
+}
+const REACT_NATIVE_EVENT_HANDLER_NAMES = loadReactEventHandlerNames();
+/**
+ * Emitted into every react.d.ts.
+ * onChange/onInput use method signatures for bivariant parameter checking so both
+ * native Event and CustomEvent callbacks are accepted without cast.
+ */
+const HELPER_TYPES = `\
+/** @internal Maps a web component class to its public props only.
+ * keyof T skips private/protected members, so this avoids the TS error
+ * "property may not be private or protected" on exported anonymous types. */
+type PublicOf<T> = { [K in keyof T]?: T[K] };
+
+/** @internal Safe React HTML attributes for web component wrappers.
+ * onChange/onInput use method signatures for bivariant parameter checking so both
+ * native Event and CustomEvent callbacks are accepted. */
+interface HTMLWCProps extends React.AriaAttributes {
+  className?: string; style?: React.CSSProperties; id?: string; slot?: string;
+  tabIndex?: number; dir?: string; lang?: string; title?: string;
+  onClick?: React.MouseEventHandler<HTMLElement>;
+  onDoubleClick?: React.MouseEventHandler<HTMLElement>;
+  onContextMenu?: React.MouseEventHandler<HTMLElement>;
+  onMouseEnter?: React.MouseEventHandler<HTMLElement>;
+  onMouseLeave?: React.MouseEventHandler<HTMLElement>;
+  onMouseDown?: React.MouseEventHandler<HTMLElement>;
+  onMouseUp?: React.MouseEventHandler<HTMLElement>;
+  onMouseMove?: React.MouseEventHandler<HTMLElement>;
+  onKeyDown?: React.KeyboardEventHandler<HTMLElement>;
+  onKeyUp?: React.KeyboardEventHandler<HTMLElement>;
+  onFocus?: React.FocusEventHandler<HTMLElement>;
+  onBlur?: React.FocusEventHandler<HTMLElement>;
+  onScroll?: React.UIEventHandler<HTMLElement>;
+  onWheel?: React.WheelEventHandler<HTMLElement>;
+  onChange?(e: Event): void;
+  onInput?(e: Event): void;
+}
+`;
+// ── String utilities ─────────────────────────────────────────────────────────
+function normalizeWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function normalizePropertyName(name) {
+    let s = name.trim();
+    if (!s)
+        return null;
+    const bracketQuoted = s.match(/^\[\s*['"](.+?)['"]\s*\]$/);
+    if (bracketQuoted) {
+        s = bracketQuoted[1];
+    }
+    else {
+        const bracket = s.match(/^\[\s*(.+?)\s*\]$/);
+        if (bracket)
+            s = bracket[1];
+        const quoted = s.match(/^['"](.+?)['"]$/);
+        if (quoted)
+            s = quoted[1];
+    }
+    s = s.trim();
+    if (!s || s.includes('\n') || s.includes('\r'))
+        return null;
+    return s;
+}
+function toPascalCase(value) {
+    return value
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map((part) => `${part[0].toUpperCase()}${part.slice(1)}`)
+        .join('');
+}
+// ── Type resolution utilities ─────────────────────────────────────────────────
+function isPrimitiveToken(token) {
+    return PRIMITIVE_TOKENS.has(token);
+}
+function isKnownTypeIdentifier(identifier) {
+    return KNOWN_TYPE_NAMES.has(identifier) || identifier.startsWith('globalThis.');
+}
+function getIdentifierTokens(typeText) {
+    var _a;
+    return (_a = typeText.match(IDENTIFIER_TOKEN_REGEX)) !== null && _a !== void 0 ? _a : [];
+}
+function createTypeImportState() {
+    return {
+        importsByIdentifier: new Map(),
+        ambiguousIdentifiers: new Set(),
+        usedImports: new Map(),
+        wildcardExportModules: new Set(),
+    };
+}
+function registerTypeImport(state, identifier, moduleSpecifier) {
+    if (state.ambiguousIdentifiers.has(identifier))
+        return;
+    const existing = state.importsByIdentifier.get(identifier);
+    if (existing && existing !== moduleSpecifier) {
+        state.importsByIdentifier.delete(identifier);
+        state.ambiguousIdentifiers.add(identifier);
+        return;
+    }
+    if (!existing) {
+        state.importsByIdentifier.set(identifier, moduleSpecifier);
+    }
+}
+function trackImportedIdentifierUsage(state, identifier, moduleSpecifier) {
+    if (!state.usedImports.has(moduleSpecifier)) {
+        state.usedImports.set(moduleSpecifier, new Set());
+    }
+    state.usedImports.get(moduleSpecifier).add(identifier);
+}
+function isBareModuleSpecifier(moduleSpecifier) {
+    return !!moduleSpecifier && !moduleSpecifier.startsWith('.') && !moduleSpecifier.startsWith('/');
+}
+function canUseComplexType(typeText, typeImportState) {
+    if (!typeText)
+        return false;
+    if (/[{};=]/.test(typeText) || /=>/.test(typeText))
+        return false;
+    if (!/^[A-Za-z0-9_$<>\[\]()|&,.?'"`\s:-]+$/.test(typeText))
+        return false;
+    for (const token of getIdentifierTokens(typeText)) {
+        if (isPrimitiveToken(token) || isKnownTypeIdentifier(token))
+            continue;
+        const root = token.split('.')[0];
+        if (typeImportState &&
+            !typeImportState.ambiguousIdentifiers.has(root) &&
+            typeImportState.importsByIdentifier.has(root)) {
+            trackImportedIdentifierUsage(typeImportState, root, typeImportState.importsByIdentifier.get(root));
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+function toSafeType(typeText, typeImportState) {
+    if (!typeText)
+        return 'unknown';
+    const normalized = normalizeWhitespace(typeText);
+    if (!normalized)
+        return 'unknown';
+    if (PRIMITIVE_UNION_REGEX.test(normalized))
+        return normalized;
+    if (normalized.endsWith('[]') && PRIMITIVE_UNION_REGEX.test(normalized.slice(0, -2).trim())) {
+        return normalized;
+    }
+    return canUseComplexType(normalized, typeImportState) ? normalized : 'unknown';
+}
+function extractDetailTypeFromDescription(description) {
+    var _a, _b;
+    return (_b = (_a = description === null || description === void 0 ? void 0 : description.match(/detail:\s*`([^`]+)`/)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.trim();
+}
+/**
+ * Maps a CEM event type string to a TypeScript handler signature.
+ *
+ * - Known DOM event classes (Event, MouseEvent, FocusEvent, etc.) → `(event: T) => void`
+ * - `CustomEvent<Detail>` → `(event: CustomEvent<Detail>) => void`
+ * - Bare `CustomEvent` or unresolvable types → `(event: CustomEvent<unknown>) => void`
+ */
+function toEventHandlerType(typeText, typeImportState, description) {
+    var _a;
+    if (typeText) {
+        const normalized = typeText.trim();
+        // Known DOM event classes map directly — not wrapped as CustomEvent<T> detail.
+        if (DOM_EVENT_CLASS_NAMES.has(normalized)) {
+            return `(event: ${normalized}) => void`;
+        }
+        if (normalized.startsWith('CustomEvent<')) {
+            const match = normalized.match(/^CustomEvent<(.+)>$/);
+            if (match) {
+                const detailType = toSafeType((_a = match[1]) === null || _a === void 0 ? void 0 : _a.trim(), typeImportState);
+                return `(event: CustomEvent<${detailType}>) => void`;
+            }
+        }
+        // For any other resolvable non-DOM type, treat it as the CustomEvent detail payload.
+        if (normalized !== 'CustomEvent') {
+            const safeType = toSafeType(normalized, typeImportState);
+            if (safeType !== 'unknown') {
+                return `(event: CustomEvent<${safeType}>) => void`;
+            }
+        }
+    }
+    const detailFromDesc = extractDetailTypeFromDescription(description);
+    if (detailFromDesc) {
+        return `(event: CustomEvent<${toSafeType(detailFromDesc, typeImportState)}>) => void`;
+    }
+    return '(event: CustomEvent<unknown>) => void';
+}
+// ── Path helpers ─────────────────────────────────────────────────────────────
+function getCEMManifestPath(cwd, packageJson) {
+    if (typeof packageJson.customElements === 'string' && packageJson.customElements.trim()) {
+        return (0, node_path_1.resolve)(cwd, packageJson.customElements);
+    }
+    return (0, node_path_1.resolve)(cwd, 'dist/custom-elements.json');
+}
+// CEM paths are relative to src/ (e.g. "src/entities/entities.ts").
+// react.mjs/cjs live in dist/ while compiled JS lives in dist/esm/.
+function cemModulePathToJsImport(modulePath) {
+    let p = modulePath.startsWith('src/') ? modulePath.slice(4) : modulePath;
+    if (p.endsWith('.tsx'))
+        p = `${p.slice(0, -4)}.js`;
+    else if (p.endsWith('.ts'))
+        p = `${p.slice(0, -3)}.js`;
+    return `./esm/${p}`;
+}
+function cemModulePathToDtsImport(modulePath) {
+    let p = modulePath.startsWith('src/') ? modulePath.slice(4) : modulePath;
+    const lastDot = p.lastIndexOf('.');
+    return `./${lastDot !== -1 ? p.slice(0, lastDot) : p}`;
+}
+// ── CEM traversal ─────────────────────────────────────────────────────────────
+function collectCustomElements(manifest) {
+    var _a, _b, _c;
+    const elements = [];
+    for (const mod of (_a = manifest.modules) !== null && _a !== void 0 ? _a : []) {
+        const modulePath = (_b = mod.path) !== null && _b !== void 0 ? _b : '';
+        for (const decl of (_c = mod.declarations) !== null && _c !== void 0 ? _c : []) {
+            if (decl.customElement && decl.tagName) {
+                elements.push({ declaration: decl, modulePath });
+            }
+        }
+    }
+    return elements;
+}
+function mergeUniqueByKey(base, extra, getKey) {
+    const merged = [...base];
+    const knownKeys = new Set(base.map(getKey).filter((k) => !!k));
+    for (const item of extra) {
+        const key = getKey(item);
+        if (!key || !knownKeys.has(key)) {
+            merged.push(item);
+            if (key)
+                knownKeys.add(key);
+        }
+    }
+    return merged;
+}
+function mergeDeclarationMetadata(base, inherited) {
+    var _a, _b, _c, _d, _e, _f;
+    const attrKey = (a) => { var _a, _b; return normalizePropertyName((_b = (_a = a.fieldName) !== null && _a !== void 0 ? _a : a.name) !== null && _b !== void 0 ? _b : ''); };
+    const nameKey = (m) => { var _a; return normalizePropertyName((_a = m.name) !== null && _a !== void 0 ? _a : ''); };
+    const eventKey = (e) => { var _a; return normalizePropertyName((_a = e.name) !== null && _a !== void 0 ? _a : ''); };
+    return Object.assign(Object.assign({}, base), { attributes: mergeUniqueByKey((_a = base.attributes) !== null && _a !== void 0 ? _a : [], (_b = inherited.attributes) !== null && _b !== void 0 ? _b : [], attrKey), members: mergeUniqueByKey((_c = base.members) !== null && _c !== void 0 ? _c : [], (_d = inherited.members) !== null && _d !== void 0 ? _d : [], nameKey), events: mergeUniqueByKey((_e = base.events) !== null && _e !== void 0 ? _e : [], (_f = inherited.events) !== null && _f !== void 0 ? _f : [], eventKey) });
+}
+function createDeclarationLookup(manifest) {
+    var _a, _b;
+    const byTagAndName = new Map();
+    const byTag = new Map();
+    for (const mod of (_a = manifest.modules) !== null && _a !== void 0 ? _a : []) {
+        for (const decl of (_b = mod.declarations) !== null && _b !== void 0 ? _b : []) {
+            if (!decl.customElement || !decl.tagName)
+                continue;
+            if (decl.name)
+                byTagAndName.set(`${decl.tagName}::${decl.name}`, decl);
+            if (!byTag.has(decl.tagName))
+                byTag.set(decl.tagName, decl);
+        }
+    }
+    return { byTagAndName, byTag };
+}
+function mergeFastInheritanceFromManifest(cwd, entries) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const fastManifestPath = (0, node_path_1.resolve)(cwd, 'ms-fast-components/custom-elements.json');
+        if (!(yield fileExists(fastManifestPath)))
+            return entries;
+        const fastManifest = JSON.parse(yield (0, promises_1.readFile)(fastManifestPath, 'utf8'));
+        const { byTagAndName, byTag } = createDeclarationLookup(fastManifest);
+        return entries.map((entry) => {
+            var _a, _b, _c, _d, _e, _f;
+            const { declaration } = entry;
+            if (!declaration.tagName || ((_a = declaration.superclass) === null || _a === void 0 ? void 0 : _a.package) !== '@microsoft/fast-components') {
+                return entry;
+            }
+            const inherited = (_f = (_c = byTagAndName.get(`${declaration.tagName}::${(_b = declaration.name) !== null && _b !== void 0 ? _b : ''}`)) !== null && _c !== void 0 ? _c : byTagAndName.get(`${declaration.tagName}::${(_e = (_d = declaration.superclass) === null || _d === void 0 ? void 0 : _d.name) !== null && _e !== void 0 ? _e : ''}`)) !== null && _f !== void 0 ? _f : byTag.get(declaration.tagName);
+            return inherited ? Object.assign(Object.assign({}, entry), { declaration: mergeDeclarationMetadata(declaration, inherited) }) : entry;
+        });
+    });
+}
+// ── Wrapper event helpers ─────────────────────────────────────────────────────
+function buildWrapperEventEntries(declaration) {
+    var _a;
+    const result = [];
+    const seen = new Set();
+    for (const event of (_a = declaration.events) !== null && _a !== void 0 ? _a : []) {
+        if (!event.name)
+            continue;
+        const normalized = normalizePropertyName(event.name);
+        if (!normalized)
+            continue;
+        const handlerName = `on${toPascalCase(normalized)}`;
+        if (!handlerName || REACT_NATIVE_EVENT_HANDLER_NAMES.has(handlerName) || seen.has(handlerName))
+            continue;
+        seen.add(handlerName);
+        result.push({ handlerName, eventName: event.name });
+    }
+    return result;
+}
+function groupEntriesByPath(entries) {
+    const byPath = new Map();
+    for (const entry of entries) {
+        if (!byPath.has(entry.modulePath))
+            byPath.set(entry.modulePath, []);
+        byPath.get(entry.modulePath).push(entry);
+    }
+    return byPath;
+}
+function cloneTypeImportStateForWrapper(original) {
+    return {
+        importsByIdentifier: new Map(original.importsByIdentifier),
+        ambiguousIdentifiers: new Set(original.ambiguousIdentifiers),
+        usedImports: new Map(),
+        wildcardExportModules: new Set(original.wildcardExportModules),
+    };
+}
+// ── Code generation ───────────────────────────────────────────────────────────
+function renderImportLines(usedImports) {
+    return [...usedImports.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([spec, ids]) => `import type { ${[...ids].sort().join(', ')} } from '${spec}';`);
+}
+function generateReactWrapperJs(entries, format) {
+    const valid = entries.filter((e) => e.declaration.name && e.modulePath);
+    if (!valid.length)
+        return '';
+    const esm = format === 'esm';
+    const lines = [
+        '/**',
+        ' * AUTO-GENERATED FILE - DO NOT EDIT.',
+        ' * Generated from custom-elements manifest.',
+        ' */',
+        '',
+    ];
+    if (!esm)
+        lines.push("'use strict';", '');
+    if (esm) {
+        lines.push("import { provideReactWrapper } from '@microsoft/fast-react-wrapper';", "import React from 'react';");
+    }
+    else {
+        lines.push("const { provideReactWrapper } = require('@microsoft/fast-react-wrapper');", "const React = require('react');");
+    }
+    for (const [modulePath, pathEntries] of [...groupEntriesByPath(valid).entries()].sort()) {
+        const sorted = [...pathEntries].sort((a, b) => a.declaration.name.localeCompare(b.declaration.name));
+        const jsPath = cemModulePathToJsImport(modulePath);
+        if (esm) {
+            lines.push(`import { ${sorted.map((e) => `${e.declaration.name} as ${e.declaration.name}WC`).join(', ')} } from '${jsPath}';`);
+        }
+        else {
+            lines.push(`const { ${sorted.map((e) => `${e.declaration.name}: ${e.declaration.name}WC`).join(', ')} } = require('${jsPath}');`);
+        }
+    }
+    lines.push('', 'const { wrap } = provideReactWrapper(React);', '');
+    for (const { declaration } of valid) {
+        const name = declaration.name;
+        const events = buildWrapperEventEntries(declaration);
+        const prefix = esm ? 'export const' : 'const';
+        if (!events.length) {
+            lines.push(`${prefix} ${name} = wrap(${name}WC);`);
+        }
+        else {
+            lines.push(`${prefix} ${name} = wrap(${name}WC, {`);
+            lines.push('  events: {');
+            for (const { handlerName, eventName } of events)
+                lines.push(`    ${handlerName}: '${eventName}',`);
+            lines.push('  },');
+            lines.push('});');
+        }
+        lines.push('');
+    }
+    if (!esm) {
+        lines.push('module.exports = {');
+        for (const { declaration } of valid)
+            lines.push(`  ${declaration.name},`);
+        lines.push('};', '');
+    }
+    return lines.join('\n');
+}
+function generateReactWrapperDts(entries, typeImportState) {
+    var _a;
+    const valid = entries.filter((e) => e.declaration.name && e.modulePath);
+    if (!valid.length)
+        return '';
+    const wrapperTypeState = cloneTypeImportStateForWrapper(typeImportState);
+    const classImports = [];
+    for (const [modulePath, pathEntries] of [...groupEntriesByPath(valid).entries()].sort()) {
+        const names = [...pathEntries]
+            .sort((a, b) => a.declaration.name.localeCompare(b.declaration.name))
+            .map((e) => `${e.declaration.name} as ${e.declaration.name}WC`)
+            .join(', ');
+        classImports.push(`import type { ${names} } from '${cemModulePathToDtsImport(modulePath)}';`);
+    }
+    const declarationLines = [];
+    for (const { declaration } of valid) {
+        const name = declaration.name;
+        // Build event lookup scoped to this element to avoid cross-element type pollution.
+        const eventsByName = new Map(((_a = declaration.events) !== null && _a !== void 0 ? _a : [])
+            .filter((e) => e.name)
+            .map((e) => [e.name, e]));
+        const eventLines = buildWrapperEventEntries(declaration).map(({ handlerName, eventName }) => {
+            var _a;
+            const event = eventsByName.get(eventName);
+            const handlerType = toEventHandlerType((_a = event === null || event === void 0 ? void 0 : event.type) === null || _a === void 0 ? void 0 : _a.text, wrapperTypeState, event === null || event === void 0 ? void 0 : event.description);
+            return `      ${handlerName}?: ${handlerType};`;
+        });
+        declarationLines.push(`export declare const ${name}: React.ForwardRefExoticComponent<`, `  React.PropsWithChildren<`, `    Omit<PublicOf<${name}WC>, 'children' | 'style'> &`, `    HTMLWCProps & {`, ...eventLines, '    }', `  > & React.RefAttributes<${name}WC>`, '>;', '');
+    }
+    return [
+        '/**',
+        ' * AUTO-GENERATED FILE - DO NOT EDIT.',
+        ' * Generated from custom-elements manifest.',
+        ' */',
+        '',
+        "import type React from 'react';",
+        ...classImports,
+        ...renderImportLines(wrapperTypeState.usedImports),
+        '',
+        HELPER_TYPES,
+        ...declarationLines,
+        'export {};',
+        '',
+    ].join('\n');
+}
+// ── File system helpers ───────────────────────────────────────────────────────
+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 collectFilesRecursively(rootDirectory, isTargetFile) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const files = [];
+        const stack = [rootDirectory];
+        while (stack.length) {
+            const dir = stack.pop();
+            const dirEntries = yield (0, promises_1.readdir)(dir, { withFileTypes: true });
+            for (const entry of dirEntries) {
+                const fullPath = (0, node_path_1.resolve)(dir, entry.name);
+                if (entry.isDirectory())
+                    stack.push(fullPath);
+                else if (entry.isFile() && isTargetFile(entry.name))
+                    files.push(fullPath);
+            }
+        }
+        return files;
+    });
+}
+function collectTypeMetadataFiles(distDirectory) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const [apiJsonFiles, dtsFiles] = yield Promise.all([
+            collectFilesRecursively(distDirectory, (n) => n.endsWith('.api.json')),
+            collectFilesRecursively(distDirectory, (n) => n.endsWith('.d.ts')),
+        ]);
+        return { apiJsonFiles, dtsFiles };
+    });
+}
+// ── Type import state builders ────────────────────────────────────────────────
+function addCanonicalReferenceFromValue(value, state) {
+    if (!value || typeof value !== 'object')
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            addCanonicalReferenceFromValue(item, state);
+        return;
+    }
+    const record = value;
+    if (typeof record.canonicalReference === 'string') {
+        const match = record.canonicalReference.match(/^(@[^!]+)!([^:]+):/);
+        if (match) {
+            const [, moduleSpecifier, identifier] = match;
+            if (identifier && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(identifier)) {
+                registerTypeImport(state, identifier, moduleSpecifier);
+            }
+        }
+    }
+    for (const nested of Object.values(record)) {
+        if (nested && typeof nested === 'object')
+            addCanonicalReferenceFromValue(nested, state);
+    }
+}
+function parseImportsFromDtsContent(content, state) {
+    var _a, _b, _c;
+    const blockRe = /(?:import|export)\s+(?:type\s+)?\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+    for (const match of content.matchAll(blockRe)) {
+        const moduleSpecifier = (_a = match[2]) !== null && _a !== void 0 ? _a : '';
+        if (!isBareModuleSpecifier(moduleSpecifier))
+            continue;
+        for (const raw of ((_b = match[1]) !== null && _b !== void 0 ? _b : '').split(',')) {
+            const entry = raw.trim();
+            if (!entry)
+                continue;
+            const alias = entry.match(/^([A-Za-z_$][A-Za-z0-9_$]*)\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)$/);
+            if (alias) {
+                registerTypeImport(state, alias[2], moduleSpecifier);
+                continue;
+            }
+            if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(entry))
+                registerTypeImport(state, entry, moduleSpecifier);
+        }
+    }
+    const reExportRe = /export\s+\*\s+from\s+['"]([^'"]+)['"]/g;
+    for (const match of content.matchAll(reExportRe)) {
+        const moduleSpecifier = (_c = match[1]) !== null && _c !== void 0 ? _c : '';
+        if (isBareModuleSpecifier(moduleSpecifier))
+            state.wildcardExportModules.add(moduleSpecifier);
+    }
+}
+function parseApiJsonFiles(filePaths, state) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(filePaths.map((filePath) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const json = JSON.parse(yield (0, promises_1.readFile)(filePath, 'utf8'));
+            addCanonicalReferenceFromValue(json, state);
+        })));
+    });
+}
+function parseDtsFiles(filePaths, state) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(filePaths.map((filePath) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            parseImportsFromDtsContent(yield (0, promises_1.readFile)(filePath, 'utf8'), state);
+        })));
+    });
+}
+function mergeTypeImportStateInto(target, source) {
+    for (const id of source.ambiguousIdentifiers) {
+        target.importsByIdentifier.delete(id);
+        target.ambiguousIdentifiers.add(id);
+    }
+    for (const [identifier, spec] of source.importsByIdentifier) {
+        registerTypeImport(target, identifier, spec);
+    }
+    for (const mod of source.wildcardExportModules) {
+        target.wildcardExportModules.add(mod);
+    }
+}
+function findWorkspaceRoot(startDirectory) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let dir = startDirectory;
+        while (true) {
+            const [hasPackages, hasPackageJson] = yield Promise.all([
+                fileExists((0, node_path_1.resolve)(dir, 'packages')),
+                fileExists((0, node_path_1.resolve)(dir, 'package.json')),
+            ]);
+            if (hasPackages && hasPackageJson)
+                return dir;
+            const parent = (0, node_path_1.dirname)(dir);
+            if (parent === dir)
+                return startDirectory;
+            dir = parent;
+        }
+    });
+}
+function getWorkspacePackageDirectoryByName(workspaceRoot, packageName) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const packagesDir = (0, node_path_1.resolve)(workspaceRoot, 'packages');
+        if (!(yield fileExists(packagesDir)))
+            return undefined;
+        const packageJsonFiles = yield collectFilesRecursively(packagesDir, (n) => n === 'package.json');
+        for (const jsonPath of packageJsonFiles) {
+            const pkg = JSON.parse(yield (0, promises_1.readFile)(jsonPath, 'utf8'));
+            if (pkg.name === packageName)
+                return (0, node_path_1.dirname)(jsonPath);
+        }
+        return undefined;
+    });
+}
+function enrichFromWorkspaceWildcardExports(cwd, state) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const workspaceRoot = yield findWorkspaceRoot(cwd);
+        // for...of over a Set processes items added inside the loop (spec-guaranteed behaviour).
+        const pending = new Set([...state.wildcardExportModules].filter((m) => m.startsWith('@genesislcap/')));
+        for (const moduleSpecifier of pending) {
+            const pkgDir = yield getWorkspacePackageDirectoryByName(workspaceRoot, moduleSpecifier);
+            if (!pkgDir)
+                continue;
+            const distDir = (0, node_path_1.resolve)(pkgDir, 'dist');
+            if (!(yield fileExists(distDir)))
+                continue;
+            const refState = createTypeImportState();
+            const { apiJsonFiles, dtsFiles } = yield collectTypeMetadataFiles(distDir);
+            yield parseApiJsonFiles(apiJsonFiles, refState);
+            yield parseDtsFiles(dtsFiles, refState);
+            mergeTypeImportStateInto(state, refState);
+            for (const mod of refState.wildcardExportModules) {
+                if (mod.startsWith('@genesislcap/'))
+                    pending.add(mod);
+            }
+        }
+    });
+}
+function buildTypeImportState(cwd) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const state = createTypeImportState();
+        const distDir = (0, node_path_1.resolve)(cwd, 'dist');
+        if (!(yield fileExists(distDir)))
+            return state;
+        const { apiJsonFiles, dtsFiles } = yield collectTypeMetadataFiles(distDir);
+        yield parseApiJsonFiles(apiJsonFiles, state);
+        yield parseDtsFiles(dtsFiles, state);
+        yield enrichFromWorkspaceWildcardExports(cwd, state);
+        return state;
+    });
+}
+// ── Entry point ───────────────────────────────────────────────────────────────
+function generateReactWrappers(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 rawEntries = collectCustomElements(manifest);
+        if (!rawEntries.length) {
+            return { generated: false, reason: 'No custom elements discovered in manifest.' };
+        }
+        const entries = yield mergeFastInheritanceFromManifest(cwd, rawEntries);
+        const hasEvents = entries.some((e) => { var _a; return ((_a = e.declaration.events) !== null && _a !== void 0 ? _a : []).length > 0; });
+        if (!hasEvents) {
+            return { generated: false, reason: 'No custom events found in any element.' };
+        }
+        const dtsRoot = (0, node_path_1.resolve)(cwd, 'dist/dts');
+        yield (0, promises_1.mkdir)(dtsRoot, { recursive: true });
+        const typeImportState = yield buildTypeImportState(cwd);
+        const reactDtsPath = (0, node_path_1.resolve)(dtsRoot, 'react.d.ts');
+        yield Promise.all([
+            (0, promises_1.writeFile)((0, node_path_1.resolve)(cwd, 'dist/react.mjs'), generateReactWrapperJs(entries, 'esm'), 'utf8'),
+            (0, promises_1.writeFile)((0, node_path_1.resolve)(cwd, 'dist/react.cjs'), generateReactWrapperJs(entries, 'cjs'), 'utf8'),
+            (0, promises_1.writeFile)(reactDtsPath, generateReactWrapperDts(entries, typeImportState), 'utf8'),
+        ]);
+        return { generated: true, path: reactDtsPath };
+    });
+}