eslint-plugin-mdx/lib/esm.js

import { __assign, __spreadArray } from 'tslib';
import { version } from 'eslint/package.json';
import { JSX_TYPES, isJsxNode, openTag, DEFAULT_EXTENSIONS, MARKDOWN_EXTENSIONS } from 'eslint-mdx';
import reactNoUnescapedEntities from 'eslint-plugin-react/lib/rules/no-unescaped-entities';
import esLintNoUnusedExpressions from 'eslint/lib/rules/no-unused-expressions';
import path from 'path';
import vfile from 'vfile';
import { cosmiconfigSync } from 'cosmiconfig';
import remarkMdx from 'remark-mdx';
import remarkParse from 'remark-parse';
import remarkStringify from 'remark-stringify';
import unified from 'unified';

var base = {
    parser: 'eslint-mdx',
    plugins: ['mdx'],
};

var getGlobals = function (sources, initialGlobals) {
    if (initialGlobals === void 0) { initialGlobals = {}; }
    return (Array.isArray(sources)
        ? sources
        : Object.keys(sources)).reduce(function (globals, source) {
        var _a;
        return Object.assign(globals, (_a = {},
            _a[source] = false,
            _a));
    }, initialGlobals);
};

var rebass;
try {
    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
    rebass = require('rebass');
}
catch (_a) {
    // `rebass`(or `reflexbox` actually) requires `react` as peerDependency, but not all projects using `mdx` are `React` based, so we fallback to hardcoded `rebass` Components here
    /* istanbul ignore next */
    rebass = ['Box', 'Flex', 'Text', 'Heading', 'Link', 'Button', 'Image', 'Card'];
}
var overrides$1 = __assign(__assign({}, base), { globals: getGlobals(rebass, {
        React: false,
    }), rules: {
        'lines-between-class-members': 0,
        'react/jsx-no-undef': [
            2,
            {
                allowGlobals: true,
            },
        ],
        'react/react-in-jsx-scope': 0,
    } });

var minorVersion = +version.split('.').slice(0, 2).join('.');
var recommended = __assign(__assign({}, base), { rules: {
        'mdx/no-jsx-html-comments': 2,
        'mdx/no-unescaped-entities': 1,
        'mdx/no-unused-expressions': 2,
        'mdx/remark': 1,
        'no-unused-expressions': 0,
        'react/no-unescaped-entities': 0,
    } });
var OVERRIDES_AVAILABLE_VERSION = 6.4;
// overrides in npm pkg is supported after v6.4.0
// istanbul ignore else
if (minorVersion >= OVERRIDES_AVAILABLE_VERSION) {
    var overrides = [
        {
            files: '*.mdx',
            extends: 'plugin:mdx/overrides',
        },
    ];
    try {
        // eslint-disable-next-line node/no-extraneous-require
        require.resolve('prettier');
        // eslint-disable-next-line node/no-extraneous-require
        require.resolve('eslint-plugin-prettier');
        overrides.push({
            files: '*.md',
            rules: {
                'prettier/prettier': [
                    2,
                    {
                        parser: 'markdown',
                    },
                ],
            },
        });
    }
    catch (_a) { }
    Object.assign(recommended, {
        overrides: overrides,
    });
}

var index = /*#__PURE__*/Object.freeze({
  __proto__: null,
  base: base,
  overrides: overrides$1,
  recommended: recommended
});

var noJsxHtmlComments = {
    meta: {
        type: 'problem',
        docs: {
            description: 'Forbid invalid html style comments in jsx block',
            category: 'SyntaxError',
            recommended: true,
        },
        messages: {
            jsxHtmlComments: 'html style comments are invalid in jsx: {{ origin }}',
        },
        fixable: 'code',
    },
    create: function (context) {
        return {
            ExpressionStatement: function (node) {
                var invalidNodes = context.parserServices
                    .JSXElementsWithHTMLComments;
                if (!JSX_TYPES.includes(node.expression.type) ||
                    node.parent.type !== 'Program' ||
                    !invalidNodes ||
                    invalidNodes.length === 0) {
                    return;
                }
                var invalidNode = invalidNodes.shift();
                if (invalidNode.data.inline) {
                    return;
                }
                var comments = invalidNode.data.comments;
                var _loop_1 = function (fixed, loc, origin_1) {
                    context.report({
                        messageId: 'jsxHtmlComments',
                        data: {
                            origin: origin_1,
                        },
                        loc: loc,
                        node: node,
                        fix: function (fixer) {
                            return fixer.replaceTextRange([loc.start.offset, loc.end.offset], fixed);
                        },
                    });
                };
                for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) {
                    var _a = comments_1[_i], fixed = _a.fixed, loc = _a.loc, origin_1 = _a.origin;
                    _loop_1(fixed, loc, origin_1);
                }
            },
        };
    },
};

/// <reference path="../../typings.d.ts" />
// copied from `eslint-plugin-react`
var DEFAULTS = [
    {
        char: '>',
        alternatives: ['&gt;'],
    },
    {
        char: '"',
        alternatives: ['&quot;', '&ldquo;', '&#34;', '&rdquo;'],
    },
    {
        char: "'",
        alternatives: ['&apos;', '&lsquo;', '&#39;', '&rsquo;'],
    },
    {
        char: '}',
        alternatives: ['&#125;'],
    },
];
var EXPRESSION = 'Literal, JSXText';
var noUnescapedEntities = __assign(__assign({}, reactNoUnescapedEntities), { create: function (context) {
        var _a;
        var configuration = (context.options[0] || {});
        var entities = configuration.forbid || DEFAULTS;
        return _a = {},
            // eslint-disable-next-line sonarjs/cognitive-complexity
            _a[EXPRESSION] = function (node) {
                var parent = node.parent, loc = node.loc;
                if (!isJsxNode(parent)) {
                    return;
                }
                while (parent) {
                    if (parent.parent.type === 'Program') {
                        break;
                    }
                    else {
                        parent = parent.parent;
                    }
                }
                var _a = loc.start, startLine = _a.line, startColumn = _a.column, _b = loc.end, endLine = _b.line, endColumn = _b.column;
                var lines = context.getSourceCode().lines;
                var firstLineOffset = parent.loc.start.line < startLine
                    ? 0
                    : lines
                        .slice(startLine - 1, endLine)
                        .join('\n')
                        .search(openTag);
                /* istanbul ignore if */
                if (firstLineOffset < 0) {
                    // should never happen, just for robustness
                    firstLineOffset = 0;
                }
                for (var i = startLine; i <= endLine; i++) {
                    var rawLine = lines[i - 1];
                    var start = 0;
                    var end = rawLine.length;
                    if (i === startLine) {
                        start = startColumn + firstLineOffset;
                    }
                    if (i === endLine) {
                        end = endColumn;
                        if (i === startLine) {
                            end += firstLineOffset;
                        }
                    }
                    rawLine = rawLine.slice(start, end);
                    for (var _i = 0, entities_1 = entities; _i < entities_1.length; _i++) {
                        var entity = entities_1[_i];
                        // eslint-disable-next-line unicorn/no-for-loop
                        for (var index = 0; index < rawLine.length; index++) {
                            var char = rawLine[index];
                            if (typeof entity === 'string') {
                                if (char === entity) {
                                    context.report({
                                        loc: { line: i, column: start + index },
                                        message: "HTML entity, `" + entity + "` , must be escaped.",
                                        node: node,
                                    });
                                }
                            }
                            else if (char === entity.char) {
                                context.report({
                                    loc: { line: i, column: start + index },
                                    message: "`" + entity.char + "` can be escaped with " + entity.alternatives
                                        .map(function (alt) { return '``'.split('').join(alt); })
                                        .join(', ') + ".",
                                    node: node,
                                });
                            }
                        }
                    }
                }
            },
            _a;
    } });

/// <reference path="../../typings.d.ts" />
var noUnusedExpressions = __assign(__assign({}, esLintNoUnusedExpressions), { create: function (context) {
        var esLintRuleListener = esLintNoUnusedExpressions.create(context);
        return {
            ExpressionStatement: function (node) {
                if (isJsxNode(node.expression) && node.parent.type === 'Program') {
                    return;
                }
                esLintRuleListener.ExpressionStatement(node);
            },
        };
    } });

var requirePkg = function (plugin, prefix, filePath) {
    if (filePath && /^\.\.?([/\\]|$)/.test(plugin)) {
        plugin = path.resolve(path.dirname(filePath), plugin);
    }
    prefix = prefix.endsWith('-') ? prefix : prefix + '-';
    var packages = [
        plugin,
        plugin.startsWith('@')
            ? plugin.replace('/', '/' + prefix)
            : prefix + plugin,
    ];
    var error;
    for (var _i = 0, packages_1 = packages; _i < packages_1.length; _i++) {
        var pkg = packages_1[_i];
        try {
            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
            return require(pkg);
        }
        catch (err) {
            if (!error) {
                error = err;
            }
        }
    }
    throw error;
};
var searchSync;
var remarkProcessor;
var getRemarkProcessor = function (searchFrom, isMdx) {
    if (!searchSync) {
        searchSync = cosmiconfigSync('remark', {
            packageProp: 'remarkConfig',
        }).search;
    }
    if (!remarkProcessor) {
        remarkProcessor = unified().use(remarkParse).freeze();
    }
    /* istanbul ignore next */
    var result = searchSync(searchFrom) || {};
    /* istanbul ignore next */
    var _a = (result.config ||
        {}), _b = _a.plugins, plugins = _b === void 0 ? [] : _b, settings = _a.settings;
    try {
        // disable this rule automatically since we already have a parser option `extensions`
        // eslint-disable-next-line node/no-extraneous-require
        plugins.push([require.resolve('remark-lint-file-extension'), false]);
    }
    catch (_c) {
        // just ignore if the package does not exist
    }
    var initProcessor = remarkProcessor().use({ settings: settings }).use(remarkStringify);
    if (isMdx) {
        initProcessor.use(remarkMdx);
    }
    return plugins
        .reduce(function (processor, pluginWithSettings) {
        var _a = Array.isArray(pluginWithSettings)
            ? pluginWithSettings
            : [pluginWithSettings], plugin = _a[0], pluginSettings = _a.slice(1);
        return processor.use.apply(processor, __spreadArray([
            /* istanbul ignore next */
            typeof plugin === 'string'
                ? requirePkg(plugin, 'remark', result.filepath)
                : plugin], pluginSettings));
    }, initProcessor)
        .freeze();
};

var remark = {
    meta: {
        type: 'layout',
        docs: {
            description: 'Linter integration with remark plugins',
            category: 'Stylistic Issues',
            recommended: true,
        },
        messages: {
            remarkReport: '{{ source }}:{{ ruleId }} - {{ reason }}',
        },
        fixable: 'code',
    },
    create: function (context) {
        var filename = context.getFilename();
        var extname = path.extname(filename);
        var sourceCode = context.getSourceCode();
        var options = context.parserOptions;
        var isMdx = DEFAULT_EXTENSIONS.concat(options.extensions || []).includes(extname);
        var isMarkdown = MARKDOWN_EXTENSIONS.concat(options.markdownExtensions || []).includes(extname);
        return {
            Program: function (node) {
                /* istanbul ignore if */
                if (!isMdx && !isMarkdown) {
                    return;
                }
                var sourceText = sourceCode.getText(node);
                var remarkProcessor = getRemarkProcessor(filename, isMdx);
                var file = vfile({
                    path: filename,
                    contents: sourceText,
                });
                try {
                    remarkProcessor.processSync(file);
                }
                catch (err) {
                    /* istanbul ignore next */
                    if (!file.messages.includes(err)) {
                        file.message(err).fatal = true;
                    }
                }
                var _loop_1 = function (source, reason, ruleId, start, end) {
                    context.report({
                        messageId: 'remarkReport',
                        data: {
                            reason: reason,
                            source: source,
                            ruleId: ruleId,
                        },
                        loc: {
                            // ! eslint ast column is 0-indexed, but unified is 1-indexed
                            start: __assign(__assign({}, start), { column: start.column - 1 }),
                            end: __assign(__assign({}, end), { column: end.column - 1 }),
                        },
                        node: node,
                        fix: function (fixer) {
                            /* istanbul ignore if */
                            if (start.offset == null) {
                                return null;
                            }
                            var range = [
                                start.offset,
                                /* istanbul ignore next */
                                end.offset == null ? start.offset + 1 : end.offset,
                            ];
                            var partialText = sourceText.slice.apply(sourceText, range);
                            var fixed = remarkProcessor.processSync(partialText).toString();
                            return fixer.replaceTextRange(range, 
                            /* istanbul ignore next */
                            partialText.endsWith('\n') ? fixed : fixed.slice(0, -1));
                        },
                    });
                };
                for (var _i = 0, _a = file.messages; _i < _a.length; _i++) {
                    var _b = _a[_i], source = _b.source, reason = _b.reason, ruleId = _b.ruleId, _c = _b.location, start = _c.start, end = _c.end;
                    _loop_1(source, reason, ruleId, start, end);
                }
            },
        };
    },
};

var rules = {
    'no-jsx-html-comments': noJsxHtmlComments,
    'no-unescaped-entities': noUnescapedEntities,
    'no-unused-expressions': noUnusedExpressions,
    remark: remark,
};

export { index as configs, getGlobals, getRemarkProcessor, noJsxHtmlComments, noUnescapedEntities, noUnusedExpressions, remark, requirePkg, rules };