eslint-plugin-toml 0.13.0 → 1.0.0

package/README.md

@@ -39,8 +39,8 @@ npm install --save-dev eslint eslint-plugin-toml
 
 > **Requirements**
 >
-> - ESLint v6.0.0 and above
-> - Node.js v12.22.x, v14.17.x, v16.x and above
+> - ESLint v9.38.0 and above
+> - Node.js v20.19.x, v22.13.x, v24.x and above
 
 <!--DOCS_IGNORE_END-->
 
@@ -51,18 +51,16 @@ npm install --save-dev eslint eslint-plugin-toml
 
 ### Configuration
 
-#### New Config (`eslint.config.js`)
-
-Use `eslint.config.js` file to configure rules. See also: <https://eslint.org/docs/latest/use/configure/configuration-files-new>.
+Use `eslint.config.js` file to configure rules. See also: <https://eslint.org/docs/latest/use/configure/configuration-files>.
 
 Example **eslint.config.js**:
 
-```mjs
+```js
 import eslintPluginToml from 'eslint-plugin-toml';
 export default [
   // add more generic rule sets here, such as:
   // js.configs.recommended,
-  ...eslintPluginToml.configs['flat/recommended'],
+  ...eslintPluginToml.configs.recommended,
   {
     rules: {
       // override/add rules settings here, such as:
@@ -74,87 +72,42 @@ export default [
 
 This plugin provides configs:
 
-- `*.configs['flat/base']` ... Configuration to enable correct TOML parsing.
-- `*.configs['flat/recommended']` ... Above, plus rules to prevent errors or unintended behavior.
-- `*.configs['flat/standard']` ... Above, plus rules to enforce the common stylistic conventions.
-
-See [the rule list](https://ota-meshi.github.io/eslint-plugin-toml/rules/) to get the `rules` that this plugin provides.
-
-#### Legacy Config (`.eslintrc`)
-
-Use `.eslintrc.*` file to configure rules. See also: <https://eslint.org/docs/latest/use/configure/>.
-
-Example **.eslintrc.js**:
-
-```js
-module.exports = {
-  extends: [
-    // add more generic rulesets here, such as:
-    // 'eslint:recommended',
-    'plugin:toml/standard'
-  ],
-  rules: {
-    // override/add rules settings here, such as:
-    // 'toml/rule-name': 'error'
-  }
-}
-```
-
-This plugin provides configs:
+- `*.configs.base` ... Configuration to enable correct TOML parsing.
+- `*.configs.recommended` ... Above, plus rules to prevent errors or unintended behavior.
+- `*.configs.standard` ... Above, plus rules to enforce the common stylistic conventions.
 
-- `plugin:toml/base` ... Configuration to enable correct TOML parsing.
-- `plugin:toml/recommended` ... Above, plus rules to prevent errors or unintended behavior.
-- `plugin:toml/standard` ... Above, plus rules to enforce the common stylistic conventions.
+For backward compatibility, you can also use the `flat/*` namespace:
 
-Note that these configurations do not enable ESLint's core rules.
-For example, the following style rules can also be used in TOML.
-
-```json5
-{
-    "rules": {
-        "comma-spacing": "error",
-        "no-multi-spaces": ["error", { "exceptions": { "TOMLKeyValue": true } }],
-        "no-multiple-empty-lines": "error",
-        "no-trailing-spaces": "error"
-    }
-}
-```
+- `*.configs['flat/base']`
+- `*.configs['flat/recommended']`
+- `*.configs['flat/standard']`
 
 See [the rule list](https://ota-meshi.github.io/eslint-plugin-toml/rules/) to get the `rules` that this plugin provides.
 
-#### Parser Configuration
+#### Languages
+
+This plugin provides the following language identifiers for use in ESLint configurations:
 
-If you have specified a parser, you need to configure a parser for `.toml`.
+- `toml/toml` ... TOML files
 
-For example, if you are using the `"@babel/eslint-parser"`, configure it as follows:
+For example, to apply settings specifically to TOML files, you can use the `language` field in your ESLint configuration:
 
 ```js
-module.exports = {
-  // ...
-  extends: ["plugin:toml/standard"],
-  // ...
-  parser: "@babel/eslint-parser",
-  // Add an `overrides` section to add a parser configuration for TOML.
-  overrides: [
-    {
-      files: ["*.toml"],
-      parser: "toml-eslint-parser",
+import eslintPluginToml from 'eslint-plugin-toml';
+export default [
+  {
+    files: ["*.toml", "**/*.toml"],
+    plugins: {
+      toml: eslintPluginToml,
     },
-  ],
-  // ...
-};
+    language: "toml/toml",
+  }
+]
 ```
 
-### Running ESLint from the command line
-
-If you want to run `eslint` from the command line, make sure you include the `.toml` extension using [the `--ext` option](https://eslint.org/docs/user-guide/configuring#specifying-file-extensions-to-lint) or a glob pattern, because ESLint targets only `.js` files by default.
+The configuration above is included in the shareable configs provided by this plugin, so using `configs` is generally recommended.
 
-Examples:
-
-```bash
-eslint --ext .js,.toml src
-eslint "src/**/*.{js,toml}"
-```
+See also <https://eslint.org/docs/latest/use/configure/plugins#specify-a-language>
 
 ## :computer: Editor Integrations
 

package/lib/chunk-15K8U1wQ.mjs

@@ -0,0 +1,18 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll as t };

package/lib/index.d.mts

@@ -0,0 +1,215 @@
+import { AST, TOMLVersionOption } from "toml-eslint-parser";
+import { IDirective, TextSourceCodeBase, TraversalStep } from "@eslint/plugin-kit";
+import * as _eslint_core0 from "@eslint/core";
+import { File, FileProblem, Language, OkParseResult, RuleDefinition, RulesConfig } from "@eslint/core";
+import { Linter, Scope } from "eslint";
+
+//#region src/meta.d.ts
+declare namespace meta_d_exports {
+  export { name, version };
+}
+declare const name: string;
+declare const version: string;
+//#endregion
+//#region src/language/token-store.d.ts
+
+type FilterPredicate = (tokenOrComment: TOMLToken) => boolean;
+type CursorWithSkipOptions = number | FilterPredicate | {
+  includeComments?: boolean;
+  filter?: FilterPredicate;
+  skip?: number;
+};
+type CursorWithCountOptions = number | FilterPredicate | {
+  includeComments?: boolean;
+  filter?: FilterPredicate;
+  count?: number;
+};
+//#endregion
+//#region src/language/toml-source-code.d.ts
+/**
+ * TOML-specific syntax element type
+ */
+type TOMLSyntaxElement = AST.TOMLNode | AST.Token | AST.Comment;
+type TOMLToken = AST.Token | AST.Comment;
+/**
+ * TOML Source Code Object
+ */
+declare class TOMLSourceCode extends TextSourceCodeBase<{
+  LangOptions: Record<never, never>;
+  RootNode: AST.TOMLProgram;
+  SyntaxElementWithLoc: TOMLSyntaxElement;
+  ConfigNode: AST.Comment;
+}> {
+  #private;
+  readonly hasBOM: boolean;
+  readonly parserServices: {
+    isTOML?: boolean;
+    parseError?: unknown;
+  };
+  readonly visitorKeys: Record<string, string[]>;
+  private readonly tokenStore;
+  /**
+   * Creates a new instance.
+   */
+  constructor(config: {
+    text: string;
+    ast: AST.TOMLProgram;
+    hasBOM: boolean;
+    parserServices: {
+      isTOML: boolean;
+      parseError?: unknown;
+    };
+    visitorKeys?: Record<string, string[]> | null | undefined;
+  });
+  traverse(): Iterable<TraversalStep>;
+  /**
+   * Gets all tokens and comments.
+   */
+  get tokensAndComments(): TOMLToken[];
+  getLines(): string[];
+  getAllComments(): AST.Comment[];
+  /**
+   * Returns an array of all inline configuration nodes found in the source code.
+   * This includes eslint-disable, eslint-enable, eslint-disable-line,
+   * eslint-disable-next-line, and eslint (for inline config) comments.
+   */
+  getInlineConfigNodes(): AST.Comment[];
+  /**
+   * Returns directives that enable or disable rules along with any problems
+   * encountered while parsing the directives.
+   */
+  getDisableDirectives(): {
+    directives: IDirective[];
+    problems: FileProblem[];
+  };
+  /**
+   * Returns inline rule configurations along with any problems
+   * encountered while parsing the configurations.
+   */
+  applyInlineConfig(): {
+    configs: {
+      config: {
+        rules: RulesConfig;
+      };
+      loc: AST.SourceLocation;
+    }[];
+    problems: FileProblem[];
+  };
+  getNodeByRangeIndex(index: number): AST.TOMLNode | null;
+  getFirstToken(node: TOMLSyntaxElement): AST.Token;
+  getFirstToken(node: TOMLSyntaxElement, options?: CursorWithSkipOptions): TOMLToken | null;
+  getLastToken(node: TOMLSyntaxElement): AST.Token;
+  getLastToken(node: TOMLSyntaxElement, options?: CursorWithSkipOptions): TOMLToken | null;
+  getTokenBefore(node: TOMLSyntaxElement): AST.Token | null;
+  getTokenBefore(node: TOMLSyntaxElement, options?: CursorWithSkipOptions): TOMLToken | null;
+  getTokensBefore(node: TOMLSyntaxElement, options?: CursorWithCountOptions): TOMLToken[];
+  getTokenAfter(node: TOMLSyntaxElement): AST.Token | null;
+  getTokenAfter(node: TOMLSyntaxElement, options?: CursorWithSkipOptions): TOMLToken | null;
+  getFirstTokenBetween(left: TOMLSyntaxElement, right: TOMLSyntaxElement, options?: CursorWithSkipOptions): TOMLToken | null;
+  getTokensBetween(left: TOMLSyntaxElement, right: TOMLSyntaxElement, paddingOrOptions?: number | FilterPredicate | CursorWithCountOptions): TOMLToken[];
+  getTokens(node: AST.TOMLNode, options?: FilterPredicate | CursorWithCountOptions): TOMLToken[];
+  getCommentsBefore(nodeOrToken: TOMLSyntaxElement): AST.Comment[];
+  getCommentsAfter(nodeOrToken: TOMLSyntaxElement): AST.Comment[];
+  isSpaceBetween(first: TOMLToken, second: TOMLToken): boolean;
+  /**
+   * Compatibility for ESLint's SourceCode API
+   * @deprecated TOML does not have scopes
+   */
+  getScope(node?: AST.TOMLNode): Scope.Scope | null;
+  /**
+   * Compatibility for ESLint's SourceCode API
+   * @deprecated
+   */
+  isSpaceBetweenTokens(first: TOMLToken, second: TOMLToken): boolean;
+  private _getChildren;
+}
+//#endregion
+//#region src/language/toml-language.d.ts
+/**
+ * Parse result
+ */
+interface TOMLParseResult {
+  ok: true;
+  ast: AST.TOMLProgram;
+}
+/**
+ * Language options for TOML
+ * Currently no options are defined.
+ */
+type TOMLLanguageOptions = {
+  parserOptions?: {
+    tomlVersion?: TOMLVersionOption;
+  };
+};
+/**
+ * The TOML language implementation for ESLint.
+ */
+declare class TOMLLanguage implements Language<{
+  LangOptions: TOMLLanguageOptions;
+  Code: TOMLSourceCode;
+  RootNode: AST.TOMLProgram;
+  Node: AST.TOMLNode;
+}> {
+  /**
+   * The type of file to read.
+   */
+  fileType: "text";
+  /**
+   * The line number at which the parser starts counting.
+   */
+  lineStart: 1;
+  /**
+   * The column number at which the parser starts counting.
+   */
+  columnStart: 0;
+  /**
+   * The name of the key that holds the type of the node.
+   */
+  nodeTypeKey: "type";
+  /**
+   * Validates the language options.
+   */
+  validateLanguageOptions(_languageOptions: TOMLLanguageOptions): void;
+  normalizeLanguageOptions(languageOptions: TOMLLanguageOptions): TOMLLanguageOptions;
+  /**
+   * Parses the given file into an AST.
+   */
+  parse(file: File, context: {
+    languageOptions?: TOMLLanguageOptions;
+  }): OkParseResult<AST.TOMLProgram> | TOMLParseResult;
+  /**
+   * Creates a new SourceCode object for the given file and parse result.
+   */
+  createSourceCode(file: File, parseResult: OkParseResult<AST.TOMLProgram> | TOMLParseResult): TOMLSourceCode;
+}
+//#endregion
+//#region src/index.d.ts
+declare const configs: {
+  base: Linter.Config[];
+  recommended: Linter.Config[];
+  standard: Linter.Config[];
+  "flat/base": Linter.Config[];
+  "flat/recommended": Linter.Config[];
+  "flat/standard": Linter.Config[];
+};
+declare const rules: Record<string, RuleDefinition>;
+declare const languages: {
+  toml: TOMLLanguage;
+};
+declare const _default: {
+  meta: typeof meta_d_exports;
+  configs: {
+    base: Linter.Config[];
+    recommended: Linter.Config[];
+    standard: Linter.Config[];
+    "flat/base": Linter.Config[];
+    "flat/recommended": Linter.Config[];
+    "flat/standard": Linter.Config[];
+  };
+  rules: Record<string, RuleDefinition<_eslint_core0.RuleDefinitionTypeOptions>>;
+  languages: {
+    toml: TOMLLanguage;
+  };
+};
+//#endregion
+export { type TOMLLanguageOptions, type TOMLSourceCode, configs, _default as default, languages, meta_d_exports as meta, rules };