@onemrvapublic/design-system-mcp-server 2.0.1-rc.1

package/dist/component-parser.js

@@ -0,0 +1,646 @@
+export class ComponentParser {
+    parse(content, filePath, htmlContent = '') {
+        const componentMatch = content.match(/@Component\s*\(\s*\{([\s\S]*?)\}\s*\)/);
+        if (!componentMatch)
+            return null;
+        const decorator = componentMatch[1];
+        const selectorMatch = decorator.match(/selector:\s*['"]([^'"]+)['"]/);
+        const selector = selectorMatch ? selectorMatch[1] : 'unknown';
+        const standalone = /standalone:\s*true/.test(decorator);
+        const importsMatch = decorator.match(/imports:\s*\[([^\]]+)\]/s);
+        const imports = importsMatch
+            ? importsMatch[1]
+                .split(',')
+                .map(i => i.trim())
+                .filter(Boolean)
+            : [];
+        const classJsdoc = this.extractClassJSDoc(content);
+        const description = classJsdoc.description || `Angular component: ${selector}`;
+        const inputs = this.extractInputs(content);
+        const outputs = this.extractOutputs(content);
+        const methods = this.extractMethods(content);
+        const slots = this.extractSlots(htmlContent);
+        const accessibility = this.extractAccessibilityInfo(content, htmlContent);
+        const hostListeners = this.extractHostListeners(content);
+        const queryChildren = this.extractQueryChildren(content);
+        const hasEffects = /\beffect\s*\(/.test(content);
+        return {
+            selector,
+            description,
+            inputs,
+            outputs,
+            methods,
+            slots,
+            hostListeners,
+            queryChildren,
+            hasEffects,
+            standalone,
+            imports,
+            accessibility,
+            keywords: classJsdoc.keywords,
+            group: classJsdoc.group,
+            themes: classJsdoc.themes,
+            deprecated: classJsdoc.deprecated,
+        };
+    }
+    extractClassJSDoc(content) {
+        const componentAt = content.search(/@Component\s*\(/);
+        const exportClassAt = content.search(/export\s+class\s+/);
+        const anchorAt = componentAt !== -1
+            ? componentAt
+            : exportClassAt !== -1
+                ? exportClassAt
+                : -1;
+        if (anchorAt === -1) {
+            return { description: '', keywords: [], group: '', themes: [] };
+        }
+        const before = content.substring(0, anchorAt);
+        const jsdocEndIdx = before.lastIndexOf('*/');
+        if (jsdocEndIdx === -1) {
+            return { description: '', keywords: [], group: '', themes: [] };
+        }
+        const jsdocStartIdx = before.lastIndexOf('/**', jsdocEndIdx);
+        if (jsdocStartIdx === -1) {
+            return { description: '', keywords: [], group: '', themes: [] };
+        }
+        const between = before.substring(jsdocEndIdx + 2).trim();
+        const linesBetween = (between.match(/\n/g) || []).length;
+        if (linesBetween > 8) {
+            return { description: '', keywords: [], group: '', themes: [] };
+        }
+        const rawJsdoc = content.substring(jsdocStartIdx + 3, jsdocEndIdx);
+        const lines = rawJsdoc
+            .split('\n')
+            .map(line => line.replace(/^\s*\*\s?/, ''));
+        const firstBlock = lines.slice(0, 6).join(' ').toLowerCase();
+        if (firstBlock.includes('copyright') ||
+            firstBlock.includes('all rights reserved') ||
+            firstBlock.includes('mit license') ||
+            firstBlock.includes('apache license') ||
+            firstBlock.includes('licensed under')) {
+            return { description: '', keywords: [], group: '', themes: [] };
+        }
+        let description = '';
+        const keywords = [];
+        let group = '';
+        const themes = [];
+        let deprecated;
+        let inCodeBlock = false;
+        let inExample = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('```')) {
+                inCodeBlock = !inCodeBlock;
+                continue;
+            }
+            if (inCodeBlock)
+                continue;
+            if (trimmed.startsWith('@example')) {
+                inExample = true;
+                continue;
+            }
+            if (inExample) {
+                if (trimmed.startsWith('@')) {
+                    inExample = false;
+                }
+                else {
+                    continue; // inside @example body — skip
+                }
+            }
+            if (trimmed.startsWith('@MatKeywords')) {
+                const value = trimmed.replace('@MatKeywords', '').trim();
+                keywords.push(...value
+                    .split(',')
+                    .map(k => k.trim())
+                    .filter(Boolean));
+            }
+            else if (trimmed.startsWith('@MatGroup')) {
+                group = trimmed.replace('@MatGroup', '').trim();
+            }
+            else if (trimmed.startsWith('@MatTheme')) {
+                const value = trimmed.replace('@MatTheme', '').trim();
+                themes.push(...value
+                    .split(',')
+                    .map(t => t.trim())
+                    .filter(Boolean));
+            }
+            else if (trimmed.startsWith('@deprecated')) {
+                deprecated =
+                    trimmed.replace('@deprecated', '').trim() ||
+                        'This component is deprecated';
+            }
+            else if (!trimmed.startsWith('@') && trimmed) {
+                if (description)
+                    description += ' ';
+                description += trimmed;
+            }
+        }
+        return {
+            description: description.trim(),
+            keywords,
+            group,
+            themes,
+            deprecated,
+        };
+    }
+    extractInputs(content) {
+        const results = [];
+        const inputPattern = /((?:@\w+\([^)]*\)\s*)*)@Input\(([^)]*)\)\s*(?:public\s+|private\s+|protected\s+)?(\w+)(?:\?|!)?(?::\s*([^;=]+?))?(?:\s*=\s*([^;]+))?;/g;
+        let match;
+        while ((match = inputPattern.exec(content)) !== null) {
+            const jsdocBlock = this.extractNearbyPropertyJSDoc(content, match.index);
+            const inputOptions = match[2] || '';
+            const name = match[3];
+            const explicitType = match[4]?.trim();
+            const defaultValue = match[5]?.trim();
+            if (jsdocBlock.includes('@hidden') || jsdocBlock.includes('@internal')) {
+                continue;
+            }
+            const { description, examples, deprecated } = this.parsePropertyJSDoc(jsdocBlock);
+            const required = inputOptions.includes('required: true');
+            const type = explicitType || this.inferTypeFromValue(defaultValue) || 'any';
+            const cleanedType = this.cleanType(type);
+            const resolvedDescription = description ||
+                this.buildInputFallbackDescription({
+                    name,
+                    type: cleanedType,
+                    required,
+                    defaultValue,
+                });
+            results.push({
+                name,
+                type: cleanedType,
+                description: resolvedDescription,
+                defaultValue,
+                required,
+                deprecated,
+                examples,
+            });
+        }
+        const signalInputPattern = /(?:public\s+|private\s+|protected\s+)?(?:readonly\s+)?(\w+)\s*=\s*input(?:\.required)?<([^>]+)>\s*\(([^)]*)\)/g;
+        while ((match = signalInputPattern.exec(content)) !== null) {
+            const jsdocBlock = this.extractNearbyPropertyJSDoc(content, match.index);
+            const name = match[1];
+            const type = match[2]?.trim() || 'any';
+            const defaultValue = match[3]?.trim() || undefined;
+            if (jsdocBlock.includes('@hidden') || jsdocBlock.includes('@internal')) {
+                continue;
+            }
+            const { description, examples, deprecated } = this.parsePropertyJSDoc(jsdocBlock);
+            const required = content.includes(`${name} = input.required`);
+            const cleanedType = this.cleanType(type);
+            const resolvedDescription = description ||
+                this.buildInputFallbackDescription({
+                    name,
+                    type: cleanedType,
+                    required,
+                    defaultValue,
+                });
+            results.push({
+                name,
+                type: cleanedType,
+                description: resolvedDescription,
+                defaultValue: defaultValue || undefined,
+                required,
+                deprecated,
+                examples,
+            });
+        }
+        const signalInputNoTypePattern = /(?:public\s+|private\s+|protected\s+)?(?:readonly\s+)?(\w+)\s*=\s*input(?:\.required)?\s*\(([^)]*)\)/g;
+        while ((match = signalInputNoTypePattern.exec(content)) !== null) {
+            const jsdocBlock = this.extractNearbyPropertyJSDoc(content, match.index);
+            const name = match[1];
+            const defaultValue = match[2]?.trim() || undefined;
+            if (results.some(r => r.name === name))
+                continue;
+            if (jsdocBlock.includes('@hidden') || jsdocBlock.includes('@internal')) {
+                continue;
+            }
+            const { description, examples, deprecated } = this.parsePropertyJSDoc(jsdocBlock);
+            const required = content.includes(`${name} = input.required`);
+            const type = this.inferTypeFromValue(defaultValue) || 'any';
+            const resolvedDescription = description ||
+                this.buildInputFallbackDescription({
+                    name,
+                    type,
+                    required,
+                    defaultValue,
+                });
+            results.push({
+                name,
+                type,
+                description: resolvedDescription,
+                defaultValue: defaultValue || undefined,
+                required,
+                deprecated,
+                examples,
+            });
+        }
+        const modelPattern = /(?:public\s+|private\s+|protected\s+)?(?:readonly\s+)?(\w+)\s*=\s*model(?:\.required)?(?:<([^>]+)>)?\s*\(([^)]*)\)/g;
+        while ((match = modelPattern.exec(content)) !== null) {
+            const jsdocBlock = this.extractNearbyPropertyJSDoc(content, match.index);
+            const name = match[1];
+            const explicitType = match[2]?.trim();
+            const defaultValue = match[3]?.trim() || undefined;
+            if (jsdocBlock.includes('@hidden') || jsdocBlock.includes('@internal')) {
+                continue;
+            }
+            const { description, examples, deprecated } = this.parsePropertyJSDoc(jsdocBlock);
+            const required = content.includes(`${name} = model.required`);
+            const type = explicitType || this.inferTypeFromValue(defaultValue) || 'any';
+            const cleanedType = this.cleanType(type);
+            const resolvedDescription = description ||
+                `${this.buildInputFallbackDescription({
+                    name,
+                    type: cleanedType,
+                    required,
+                    defaultValue,
+                })} Two-way binding signal (model).`;
+            results.push({
+                name,
+                type: cleanedType,
+                description: resolvedDescription,
+                defaultValue: defaultValue || undefined,
+                required,
+                deprecated,
+                examples,
+            });
+        }
+        return results;
+    }
+    extractOutputs(content) {
+        const results = [];
+        const outputPattern = /@Output\(([^)]*)\)\s*(?:public\s+|private\s+|protected\s+)?(\w+)(?:\?|!)?(?::\s*([^;=]+?))?(?:\s*=\s*([^;]+))?;/g;
+        let match;
+        while ((match = outputPattern.exec(content)) !== null) {
+            const jsdocBlock = this.extractNearbyPropertyJSDoc(content, match.index);
+            const name = match[2];
+            const type = match[3]?.trim() || 'EventEmitter<any>';
+            if (jsdocBlock.includes('@hidden') || jsdocBlock.includes('@internal')) {
+                continue;
+            }
+            const { description, deprecated } = this.parsePropertyJSDoc(jsdocBlock);
+            const cleanedType = this.cleanType(type);
+            const resolvedDescription = description ||
+                this.buildOutputFallbackDescription({ name, type: cleanedType });
+            results.push({
+                name,
+                type: cleanedType,
+                description: resolvedDescription,
+                deprecated,
+            });
+        }
+        const signalOutputPattern = /(?:public\s+|private\s+|protected\s+)?(\w+)\s*=\s*output<([^>]+)>\s*\(\)/g;
+        while ((match = signalOutputPattern.exec(content)) !== null) {
+            const jsdocBlock = this.extractNearbyPropertyJSDoc(content, match.index);
+            const name = match[1];
+            const type = match[2]?.trim() || 'any';
+            if (jsdocBlock.includes('@hidden') || jsdocBlock.includes('@internal')) {
+                continue;
+            }
+            const { description, deprecated } = this.parsePropertyJSDoc(jsdocBlock);
+            const emittedType = `OutputEmitter<${type}>`;
+            const resolvedDescription = description ||
+                this.buildOutputFallbackDescription({
+                    name,
+                    type: emittedType,
+                });
+            results.push({
+                name,
+                type: emittedType,
+                description: resolvedDescription,
+                deprecated,
+            });
+        }
+        return results;
+    }
+    extractNearbyPropertyJSDoc(content, anchorIndex) {
+        const before = content.slice(0, anchorIndex);
+        const jsdocEndIdx = before.lastIndexOf('*/');
+        if (jsdocEndIdx === -1) {
+            return '';
+        }
+        const trailing = before.slice(jsdocEndIdx + 2);
+        if (trailing.trim() !== '') {
+            return '';
+        }
+        const jsdocStartIdx = before.lastIndexOf('/**', jsdocEndIdx);
+        if (jsdocStartIdx === -1) {
+            return '';
+        }
+        return before.slice(jsdocStartIdx + 3, jsdocEndIdx);
+    }
+    buildInputFallbackDescription(input) {
+        const requiredText = input.required ? 'Required ' : '';
+        let description = `${requiredText}Input property \`${input.name}\` of type \`${input.type || 'any'}\`.`;
+        if (input.defaultValue && input.defaultValue.trim()) {
+            description += ` Default: \`${this.truncateForDescription(input.defaultValue)}\`.`;
+        }
+        return description;
+    }
+    buildOutputFallbackDescription(output) {
+        return `Output event \`${output.name}\` emits \`${output.type || 'any'}\`.`;
+    }
+    truncateForDescription(value, maxLength = 80) {
+        const cleaned = value.replace(/\s+/g, ' ').trim();
+        if (cleaned.length <= maxLength) {
+            return cleaned;
+        }
+        return `${cleaned.substring(0, maxLength - 3)}...`;
+    }
+    extractMethods(content) {
+        const results = [];
+        const methodPattern = /(\/\*\*([\s\S]*?)\*\/\s*)?(?:public\s+)(\w+)\s*\(([^)]*)\)(?:\s*:\s*([^{]+))?\s*{/g;
+        let match;
+        while ((match = methodPattern.exec(content)) !== null) {
+            const jsdocBlock = match[2] || '';
+            const name = match[3];
+            const paramsStr = match[4] || '';
+            const returnType = match[5]?.trim() || 'void';
+            const lifecycleHooks = [
+                'ngOnInit',
+                'ngOnDestroy',
+                'ngOnChanges',
+                'ngAfterViewInit',
+                'ngAfterContentInit',
+                'ngDoCheck',
+            ];
+            if (lifecycleHooks.includes(name))
+                continue;
+            if (jsdocBlock.includes('@hidden') || jsdocBlock.includes('@internal'))
+                continue;
+            if (name.startsWith('_'))
+                continue;
+            const { description, deprecated } = this.parsePropertyJSDoc(jsdocBlock);
+            const params = [];
+            if (paramsStr.trim()) {
+                const paramParts = paramsStr.split(',');
+                for (const part of paramParts) {
+                    const paramMatch = part.trim().match(/(\w+)(?:\?)?(?::\s*(.+))?/);
+                    if (paramMatch) {
+                        params.push({
+                            name: paramMatch[1],
+                            type: paramMatch[2]?.trim() || 'any',
+                        });
+                    }
+                }
+            }
+            results.push({
+                name,
+                description,
+                params,
+                returnType: this.cleanType(returnType),
+                deprecated,
+            });
+        }
+        return results;
+    }
+    extractSlots(htmlContent) {
+        const slots = [];
+        if (!htmlContent)
+            return slots;
+        const slotPattern = /<ng-content(?:\s+select=["']([^"']+)["'])?[^>]*>/g;
+        let match;
+        while ((match = slotPattern.exec(htmlContent)) !== null) {
+            const selector = match[1] || '*';
+            const name = selector === '*' ? 'default' : selector.replace(/[.[\]]/g, '');
+            slots.push({
+                name,
+                selector,
+                description: selector === '*'
+                    ? 'Default content projection slot'
+                    : `Content projection for elements matching "${selector}"`,
+            });
+        }
+        return slots;
+    }
+    parsePropertyJSDoc(jsdoc) {
+        const lines = jsdoc.split('\n').map(line => line.replace(/^\s*\*\s?/, ''));
+        let description = '';
+        const examples = [];
+        let inExample = false;
+        let currentExample = '';
+        let deprecated;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('@example')) {
+                inExample = true;
+                currentExample = '';
+            }
+            else if (trimmed.startsWith('@deprecated')) {
+                deprecated = trimmed.replace('@deprecated', '').trim() || 'Deprecated';
+            }
+            else if (trimmed.startsWith('@') && inExample) {
+                if (currentExample.trim()) {
+                    examples.push(currentExample.trim());
+                }
+                inExample = false;
+                currentExample = '';
+            }
+            else if (inExample) {
+                if (trimmed.startsWith('```')) {
+                    continue;
+                }
+                currentExample += line + '\n';
+            }
+            else if (!trimmed.startsWith('@') && trimmed) {
+                if (description)
+                    description += ' ';
+                description += trimmed;
+            }
+        }
+        if (currentExample.trim()) {
+            examples.push(currentExample.trim());
+        }
+        return { description: description.trim(), examples, deprecated };
+    }
+    cleanType(type) {
+        return type.replace(/\s+/g, ' ').trim();
+    }
+    inferTypeFromValue(value) {
+        if (!value)
+            return null;
+        const trimmed = value.trim();
+        if (trimmed === 'true' || trimmed === 'false') {
+            return 'boolean';
+        }
+        if (trimmed === "''" ||
+            trimmed === '""' ||
+            trimmed.startsWith("'") ||
+            trimmed.startsWith('"')) {
+            return 'string';
+        }
+        if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+            return 'number';
+        }
+        if (trimmed.startsWith('[')) {
+            return 'array';
+        }
+        if (trimmed.startsWith('{')) {
+            return 'object';
+        }
+        if (trimmed === 'null' || trimmed === 'undefined') {
+            return trimmed;
+        }
+        if (trimmed.startsWith('new ')) {
+            const match = trimmed.match(/new\s+(\w+)/);
+            return match ? match[1] : null;
+        }
+        return null;
+    }
+    extractHostListeners(content) {
+        const results = [];
+        const hostListenerPattern = /@HostListener\(\s*['"]([^'"]+)['"]\s*(?:,\s*\[([^\]]*)\])?\s*\)\s*(?:\w+\s+)?(\w+)\s*\(/g;
+        let match;
+        while ((match = hostListenerPattern.exec(content)) !== null) {
+            const event = match[1];
+            const argsStr = match[2] || '';
+            const methodName = match[3];
+            const args = argsStr
+                ? argsStr
+                    .split(',')
+                    .map(a => a.trim().replace(/['"]/g, ''))
+                    .filter(Boolean)
+                : [];
+            results.push({ event, methodName, args });
+        }
+        return results;
+    }
+    extractQueryChildren(content) {
+        const results = [];
+        const queryPattern = /@(ViewChild|ContentChild|ViewChildren|ContentChildren)\(\s*(\w+)(?:\s*,\s*\{([^}]*)\})?\s*\)\s*(?:public\s+|private\s+|protected\s+)?(\w+)(?:\?|!)?(?::\s*([^;=]+?))?;/g;
+        let match;
+        while ((match = queryPattern.exec(content)) !== null) {
+            const queryType = match[1];
+            const type = match[2];
+            const options = match[3] || '';
+            const name = match[4];
+            if (name.startsWith('_'))
+                continue;
+            const isStatic = /static\s*:\s*true/.test(options);
+            const isRequired = !match[0].includes('?');
+            results.push({
+                name,
+                type,
+                queryType,
+                required: isRequired,
+                static: isStatic,
+            });
+        }
+        return results;
+    }
+    extractAccessibilityInfo(tsContent, htmlContent = '') {
+        const a11yInfo = [];
+        const combined = tsContent + '\n' + htmlContent;
+        const ariaAttrs = this.extractAriaFromHtml(htmlContent);
+        a11yInfo.push(...ariaAttrs);
+        if (tsContent.includes('aria-label') || tsContent.includes('ariaLabel')) {
+            if (!a11yInfo.some(i => i.includes('aria-label'))) {
+                a11yInfo.push('Uses aria-label for screen readers');
+            }
+        }
+        if (tsContent.includes('aria-describedby') ||
+            tsContent.includes('ariaDescribedby')) {
+            if (!a11yInfo.some(i => i.includes('aria-describedby'))) {
+                a11yInfo.push('Uses aria-describedby for descriptions');
+            }
+        }
+        const tsRoleMatch = tsContent.match(/role\s*=\s*['"](\w+)['"]/);
+        if (tsRoleMatch &&
+            !a11yInfo.some(i => i.includes(`role="${tsRoleMatch[1]}"`))) {
+            a11yInfo.push(`Defines role="${tsRoleMatch[1]}"`);
+        }
+        if (combined.includes('keydown') ||
+            combined.includes('keyup') ||
+            combined.includes('keypress')) {
+            a11yInfo.push('Supports keyboard navigation');
+        }
+        if (combined.includes('tabindex') || combined.includes('tabIndex')) {
+            a11yInfo.push('Manages focus with tabindex');
+        }
+        if (combined.includes('.focus()') ||
+            combined.includes('FocusTrap') ||
+            combined.includes('cdkTrapFocus')) {
+            a11yInfo.push('Implements focus management');
+        }
+        if (combined.includes('sr-only') ||
+            combined.includes('visually-hidden') ||
+            combined.includes('cdk-visually-hidden')) {
+            a11yInfo.push('Includes screen reader only content');
+        }
+        return [...new Set(a11yInfo)]; // Remove duplicates
+    }
+    extractAriaFromHtml(html) {
+        const a11yInfo = [];
+        if (!html)
+            return a11yInfo;
+        const roleMatches = html.matchAll(/role\s*=\s*["']([^"']+)["']/g);
+        const roles = new Set();
+        for (const match of roleMatches) {
+            roles.add(match[1]);
+        }
+        if (roles.size > 0) {
+            a11yInfo.push(`Defines roles: ${[...roles].join(', ')}`);
+        }
+        const attrRoleMatches = html.matchAll(/\[attr\.role\]\s*=\s*["']([^"']+)["']/g);
+        for (const _match of attrRoleMatches) {
+            if (!a11yInfo.some(i => i.includes('dynamic role'))) {
+                a11yInfo.push('Uses dynamic role bindings');
+            }
+        }
+        const ariaPatterns = [
+            [
+                /aria-label\s*=|attr\.aria-label/g,
+                'Uses aria-label for screen readers',
+            ],
+            [
+                /aria-labelledby\s*=|attr\.aria-labelledby/g,
+                'Uses aria-labelledby for label references',
+            ],
+            [
+                /aria-describedby\s*=|attr\.aria-describedby/g,
+                'Uses aria-describedby for descriptions',
+            ],
+            [
+                /aria-expanded\s*=|attr\.aria-expanded/g,
+                'Uses aria-expanded for expandable content',
+            ],
+            [
+                /aria-selected\s*=|attr\.aria-selected/g,
+                'Uses aria-selected for selection state',
+            ],
+            [
+                /aria-controls\s*=|attr\.aria-controls/g,
+                'Uses aria-controls for related elements',
+            ],
+            [
+                /aria-live\s*=|attr\.aria-live/g,
+                'Uses aria-live for dynamic announcements',
+            ],
+            [
+                /aria-hidden\s*=|attr\.aria-hidden/g,
+                'Uses aria-hidden for decorative elements',
+            ],
+            [
+                /aria-disabled\s*=|attr\.aria-disabled/g,
+                'Uses aria-disabled for disabled state',
+            ],
+            [
+                /aria-posinset\s*=|attr\.aria-posinset/g,
+                'Uses aria-posinset for position in set',
+            ],
+            [
+                /aria-setsize\s*=|attr\.aria-setsize/g,
+                'Uses aria-setsize for set size',
+            ],
+            [/aria-busy\s*=|attr\.aria-busy/g, 'Uses aria-busy for loading state'],
+        ];
+        for (const [pattern, message] of ariaPatterns) {
+            if (pattern.test(html)) {
+                a11yInfo.push(message);
+            }
+        }
+        return a11yInfo;
+    }
+}
+//# sourceMappingURL=component-parser.js.map