eslint-plugin-mdx

  • Version 3.6.2
  • Published
  • 88.7 kB
  • 10 dependencies
  • MIT license

Install

npm i eslint-plugin-mdx
yarn add eslint-plugin-mdx
pnpm add eslint-plugin-mdx

Overview

ESLint Plugin for MDX

Index

Variables

variable base

const base: Linter.LegacyConfig;

    variable cjsRequire

    const cjsRequire: CjsRequire;

      variable codeBlocks

      const codeBlocks: {
      parserOptions: { ecmaFeatures: { impliedStrict: true } };
      rules: {
      'eol-last': 'off';
      'no-undef': 'off';
      'no-unused-expressions': 'off';
      'no-unused-vars': 'off';
      '@typescript-eslint/no-unused-vars': 'off';
      'padded-blocks': 'off';
      strict: 'off';
      'unicode-bom': 'off';
      };
      };

        variable configs

        const configs: {
        base: any;
        'code-blocks': {
        parserOptions: { ecmaFeatures: { impliedStrict: true } };
        rules: {
        'eol-last': 'off';
        'no-undef': 'off';
        'no-unused-expressions': 'off';
        'no-unused-vars': 'off';
        '@typescript-eslint/no-unused-vars': 'off';
        'padded-blocks': 'off';
        strict: 'off';
        'unicode-bom': 'off';
        };
        };
        codeBlocks: {
        parserOptions: { ecmaFeatures: { impliedStrict: true } };
        rules: {
        'eol-last': 'off';
        'no-undef': 'off';
        'no-unused-expressions': 'off';
        'no-unused-vars': 'off';
        '@typescript-eslint/no-unused-vars': 'off';
        'padded-blocks': 'off';
        strict: 'off';
        'unicode-bom': 'off';
        };
        };
        flat: any;
        flatCodeBlocks: any;
        overrides: any;
        recommended: any;
        };

          variable DEFAULT_LANGUAGE_MAPPER

          const DEFAULT_LANGUAGE_MAPPER: {
          readonly ecmascript: 'js';
          readonly javascript: 'js';
          readonly javascriptreact: 'jsx';
          readonly typescript: 'ts';
          readonly typescriptreact: 'tsx';
          readonly markdown: 'md';
          readonly markdownjsx: 'mdx';
          readonly markdownreact: 'mdx';
          readonly mdown: 'md';
          readonly mkdn: 'md';
          };

            variable flat

            const flat: Linter.FlatConfig;

              variable flatCodeBlocks

              const flatCodeBlocks: Linter.FlatConfig;

                variable meta

                const meta: { name: string; version: string };

                  variable overrides

                  const overrides: Linter.LegacyConfig;

                    variable processorOptions

                    const processorOptions: ProcessorOptions;

                      variable processors

                      const processors: { remark: any };
                        const recommended: Linter.LegacyConfig;

                          variable remark

                          const remark: Rule.RuleModule;

                            variable rules

                            const rules: { remark: any };

                              Functions

                              function createRemarkProcessor

                              createRemarkProcessor: ({
                              languageMapper,
                              lintCodeBlocks,
                              ...syncOptions
                              }?: any) => Linter.Processor;

                                function getGlobals

                                getGlobals: <
                                T extends Record<string, unknown> | string[],
                                G extends Record<string, boolean>,
                                R extends G = G & Record<T extends (infer R_1)[] ? R_1 : keyof T, false>
                                >(
                                sources: T,
                                initialGlobals?: G
                                ) => R;

                                  function getShortLang

                                  getShortLang: (
                                  filename: string,
                                  languageMapper?: Record<string, string> | false
                                  ) => string;

                                    Interfaces

                                    interface CodeBlock

                                    interface CodeBlock extends Code {}

                                      property baseIndentText

                                      baseIndentText: string;

                                        property comments

                                        comments: string[];

                                          property rangeMap

                                          rangeMap: RangeMap[];

                                            interface ESLintMdxSettings

                                            interface ESLintMdxSettings {}

                                              property 'mdx/code-blocks'

                                              'mdx/code-blocks'?: boolean;

                                                property 'mdx/ignore-remark-config'

                                                'mdx/ignore-remark-config'?: boolean;

                                                  property 'mdx/language-mapper'

                                                  'mdx/language-mapper'?: Record<string, string> | false;

                                                    property 'mdx/remark-config-path'

                                                    'mdx/remark-config-path'?: string;

                                                      interface ExpressionStatementWithParent

                                                      interface ExpressionStatementWithParent extends ExpressionStatement, WithParent {}

                                                        interface LinterConfig

                                                        interface LinterConfig extends ESLint.Linter.LegacyConfig {}

                                                          method extractConfig

                                                          extractConfig: (filename?: string) => ESLint.Linter.LegacyConfig;

                                                            interface ProcessorOptions

                                                            interface ProcessorOptions extends SyncOptions {}

                                                              property languageMapper

                                                              languageMapper?: Record<string, string> | false;

                                                                property lintCodeBlocks

                                                                lintCodeBlocks?: boolean;

                                                                  interface RangeMap

                                                                  interface RangeMap {}

                                                                    property indent

                                                                    indent: number;

                                                                      property js

                                                                      js: number;

                                                                        property md

                                                                        md: number;

                                                                          interface RemarkLintMessage

                                                                          interface RemarkLintMessage {}

                                                                            property reason

                                                                            reason: string;

                                                                              property ruleId

                                                                              ruleId: string;

                                                                                property severity

                                                                                severity: Linter.LintMessage['severity'];

                                                                                  property source

                                                                                  source: string;

                                                                                    interface WithParent

                                                                                    interface WithParent {}

                                                                                      property parent

                                                                                      parent: NodeWithParent;

                                                                                        Type Aliases

                                                                                        type NodeWithParent

                                                                                        type NodeWithParent = Node & WithParent;

                                                                                          Package Files (17)

                                                                                          Dependencies (10)

                                                                                          Dev Dependencies (0)

                                                                                          No dev dependencies.

                                                                                          Peer Dependencies (1)

                                                                                          Badge

                                                                                          To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                          You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/eslint-plugin-mdx.

                                                                                          • Markdown
                                                                                            [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/eslint-plugin-mdx)
                                                                                          • HTML
                                                                                            <a href="https://www.jsdocs.io/package/eslint-plugin-mdx"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>