@mintlify/cli 4.0.739 → 4.0.740

package/bin/cli.js

@@ -17,6 +17,7 @@ import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { accessibilityCheck } from './accessibilityCheck.js';
 import { checkPort, checkForMintJson, checkNodeVersion, upgradeConfig, checkForDocsJson, getVersions, suppressConsoleWarnings, terminate, readLocalOpenApiFile, } from './helpers.js';
+import { mdxLinter } from './mdxLinter.js';
 import { migrateMdx } from './migrateMdx.js';
 import { update } from './update.js';
 export const cli = ({ packageName = 'mint' }) => {
@@ -173,9 +174,10 @@ export const cli = ({ packageName = 'mint' }) => {
         yield migrateMdx();
         yield terminate(0);
     }))
-        .command('accessibility-check', false, () => undefined, () => __awaiter(void 0, void 0, void 0, function* () {
-        const terminateCode = yield accessibilityCheck();
-        yield terminate(terminateCode);
+        .command(['accessibility-check', 'a11y-check', 'accessibility', 'a11y'], false, () => undefined, () => __awaiter(void 0, void 0, void 0, function* () {
+        const accessibilityCheckTerminateCode = yield accessibilityCheck();
+        const mdxLinterTerminateCode = yield mdxLinter();
+        yield terminate(accessibilityCheckTerminateCode || mdxLinterTerminateCode);
     }))
         .command(['version', 'v'], 'display the current version of the CLI and client', () => undefined, () => __awaiter(void 0, void 0, void 0, function* () {
         const { cli, client } = getVersions();

package/bin/mdxAccessibility.js

@@ -0,0 +1,111 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { coreRemark } from '@mintlify/common';
+import { categorizeFilePaths } from '@mintlify/prebuild';
+import fs from 'fs';
+import path from 'path';
+import { visit } from 'unist-util-visit';
+const checkAltAttributes = (filePath, content) => {
+    const issues = [];
+    const visitElements = () => {
+        return (tree) => {
+            visit(tree, (node) => {
+                var _a, _b, _c, _d, _e, _f;
+                if (node.type === 'image') {
+                    if (!node.alt || node.alt.trim() === '') {
+                        issues.push({
+                            filePath,
+                            line: (_a = node.position) === null || _a === void 0 ? void 0 : _a.start.line,
+                            column: (_b = node.position) === null || _b === void 0 ? void 0 : _b.start.column,
+                            element: 'img',
+                            tagName: 'image (markdown)',
+                        });
+                    }
+                    return;
+                }
+                const mdxJsxElement = node;
+                if (mdxJsxElement.name === 'img' || mdxJsxElement.name === 'video') {
+                    const altAttrIndex = mdxJsxElement.attributes.findIndex((attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'alt');
+                    const altAttribute = mdxJsxElement.attributes[altAttrIndex];
+                    const hasValidAlt = altAttribute &&
+                        typeof altAttribute.value === 'string' &&
+                        altAttribute.value.trim() !== '';
+                    if (!hasValidAlt) {
+                        issues.push({
+                            filePath,
+                            line: (_c = node.position) === null || _c === void 0 ? void 0 : _c.start.line,
+                            column: (_d = node.position) === null || _d === void 0 ? void 0 : _d.start.column,
+                            element: mdxJsxElement.name,
+                            tagName: mdxJsxElement.name,
+                        });
+                    }
+                }
+                else if (mdxJsxElement.name === 'a') {
+                    const hasTextContent = (children) => {
+                        return children.some((child) => {
+                            if (child.type === 'text') {
+                                const textNode = child;
+                                return textNode.value.trim() !== '';
+                            }
+                            if ('children' in child && Array.isArray(child.children)) {
+                                return hasTextContent(child.children);
+                            }
+                            return false;
+                        });
+                    };
+                    if (!hasTextContent(mdxJsxElement.children)) {
+                        issues.push({
+                            filePath,
+                            line: (_e = node.position) === null || _e === void 0 ? void 0 : _e.start.line,
+                            column: (_f = node.position) === null || _f === void 0 ? void 0 : _f.start.column,
+                            element: 'a',
+                            tagName: '<a>',
+                        });
+                    }
+                }
+            });
+            return tree;
+        };
+    };
+    try {
+        coreRemark().use(visitElements).processSync(content);
+    }
+    catch (error) {
+        console.warn(`Warning: Could not parse ${filePath}: ${error}`);
+    }
+    return issues;
+};
+export const checkMdxAccessibility = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (baseDir = process.cwd()) {
+    const { contentFilenames } = yield categorizeFilePaths(baseDir);
+    const mdxFiles = [];
+    for (const file of contentFilenames) {
+        mdxFiles.push(path.join(baseDir, file));
+    }
+    const allIssues = [];
+    const filesWithIssues = new Set();
+    for (const filePath of mdxFiles) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const issues = checkAltAttributes(filePath, content);
+            if (issues.length > 0) {
+                allIssues.push(...issues);
+                filesWithIssues.add(filePath);
+            }
+        }
+        catch (error) {
+            console.warn(`Warning: Could not read file ${filePath}: ${error}`);
+        }
+    }
+    return {
+        missingAltAttributes: allIssues,
+        totalFiles: mdxFiles.length,
+        filesWithIssues: filesWithIssues.size,
+    };
+});

package/bin/mdxLinter.js

@@ -0,0 +1,55 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { addLog, ErrorLog, SuccessLog } from '@mintlify/previewing';
+import { Text } from 'ink';
+import path from 'path';
+import { checkMdxAccessibility } from './mdxAccessibility.js';
+export const mdxLinter = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        addLog(_jsx(Text, { bold: true, color: "cyan", children: "Checking mdx files for accessibility issues..." }));
+        const results = yield checkMdxAccessibility();
+        if (results.missingAltAttributes.length === 0) {
+            addLog(_jsx(SuccessLog, { message: "no accessibility issues found" }));
+            addLog(_jsxs(Text, { children: ["Checked ", results.totalFiles, " MDX files - all images and videos have alt attributes."] }));
+            return 0;
+        }
+        const issuesByFile = {};
+        results.missingAltAttributes.forEach((issue) => {
+            var _a;
+            if (!issuesByFile[issue.filePath]) {
+                issuesByFile[issue.filePath] = [];
+            }
+            (_a = issuesByFile[issue.filePath]) === null || _a === void 0 ? void 0 : _a.push(issue);
+        });
+        addLog(_jsxs(Text, { bold: true, color: "red", children: ["Found ", results.missingAltAttributes.length, " accessibility issues in", ' ', results.filesWithIssues, " files:"] }));
+        addLog(_jsx(Text, {}));
+        for (const [filePath, issues] of Object.entries(issuesByFile)) {
+            const relativePath = path.relative(process.cwd(), filePath);
+            addLog(_jsxs(Text, { bold: true, children: [relativePath, ":"] }));
+            for (const issue of issues) {
+                const location = issue.line && issue.column ? ` (line ${issue.line}, col ${issue.column})` : '';
+                if (issue.element === 'a') {
+                    addLog(_jsxs(Text, { children: [_jsx(Text, { color: "red", children: " \u2717" }), " Missing text attribute ", _jsx(Text, { bold: true, children: issue.tagName }), ' ', "element", location] }));
+                }
+                else {
+                    addLog(_jsxs(Text, { children: [_jsx(Text, { color: "red", children: " \u2717" }), " Missing alt attribute on ", _jsx(Text, { bold: true, children: issue.tagName }), ' ', "element", location] }));
+                }
+            }
+            addLog(_jsx(Text, {}));
+        }
+        addLog(_jsxs(Text, { color: "yellow", children: [_jsx(Text, { bold: true, children: "Recommendation:" }), " Add alt attributes to all images and videos for better accessibility."] }));
+        return 1;
+    }
+    catch (error) {
+        addLog(_jsx(ErrorLog, { message: `MDX accessibility check failed: ${error instanceof Error ? error.message : 'Unknown error'}` }));
+        return 1;
+    }
+});