@eslint/json 0.1.0

package/dist/cjs/index.cjs

@@ -0,0 +1,491 @@
+'use strict';
+
+var momoa = require('@humanwhocodes/momoa');
+
+/**
+ * @fileoverview The JSONSourceCode class.
+ * @author Nicholas C. Zakas
+ */
+
+
+//-----------------------------------------------------------------------------
+// Types
+//-----------------------------------------------------------------------------
+
+/** @typedef {import("@humanwhocodes/momoa").DocumentNode} DocumentNode */
+/** @typedef {import("@humanwhocodes/momoa").Node} JSONNode */
+/** @typedef {import("@humanwhocodes/momoa").Token} JSONToken */
+/** @typedef {import("@eslint/core").SyntaxElement} SyntaxElement */
+/** @typedef {import("@eslint/core").Language} Language */
+/** @typedef {import("@eslint/core").File} File */
+/** @typedef {import("@eslint/core").TraversalStep} TraversalStep */
+/** @typedef {import("@eslint/core").VisitTraversalStep} VisitTraversalStep */
+/** @typedef {import("@eslint/core").TextSourceCode} TextSourceCode */
+/** @typedef {import("@eslint/core").ParseResult} ParseResult */
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+
+/**
+ * A class to represent a step in the traversal process.
+ * @implements {VisitTraversalStep}
+ */
+class JSONTraversalStep {
+	/**
+	 * The type of the step.
+	 * @type {"visit"}
+	 * @readonly
+	 */
+	type = "visit";
+
+	/**
+	 * The kind of the step. Represents the same data as the `type` property
+	 * but it's a number for performance.
+	 * @type {1}
+	 * @readonly
+	 */
+	kind = 1;
+
+	/**
+	 * The target of the step.
+	 * @type {JSONNode & SyntaxElement}
+	 */
+	target;
+
+	/**
+	 * The phase of the step.
+	 * @type {1|2}
+	 */
+	phase;
+
+	/**
+	 * The arguments of the step.
+	 * @type {Array<any>}
+	 */
+	args;
+
+	/**
+	 * Creates a new instance.
+	 * @param {Object} options The options for the step.
+	 * @param {JSONNode & SyntaxElement} options.target The target of the step.
+	 * @param {1|2} options.phase The phase of the step.
+	 * @param {Array<any>} options.args The arguments of the step.
+	 */
+	constructor({ target, phase, args }) {
+		this.target = target;
+		this.phase = phase;
+		this.args = args;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * JSON Source Code Object
+ * @implements {TextSourceCode}
+ */
+class JSONSourceCode {
+	/**
+	 * Cached traversal steps.
+	 * @type {Array<JSONTraversalStep>|undefined}
+	 */
+	#steps;
+
+	/**
+	 * Cache of parent nodes.
+	 * @type {WeakMap<JSONNode, JSONNode>}
+	 */
+	#parents = new WeakMap();
+
+	/**
+	 * The lines of text in the source code.
+	 * @type {Array<string>}
+	 */
+	#lines;
+
+	/**
+	 * The AST of the source code.
+	 * @type {DocumentNode & SyntaxElement}
+	 */
+	ast;
+
+	/**
+	 * The text of the source code.
+	 * @type {string}
+	 */
+	text;
+
+	/**
+	 * The comment node in the source code.
+	 * @type {Array<JSONToken>|undefined}
+	 */
+	comments;
+
+	/**
+	 * Creates a new instance.
+	 * @param {Object} options The options for the instance.
+	 * @param {string} options.text The source code text.
+	 * @param {DocumentNode & SyntaxElement} options.ast The root AST node.
+	 */
+	constructor({ text, ast }) {
+		this.ast = ast;
+		this.text = text;
+		this.comments = ast.tokens.filter(token =>
+			token.type.endsWith("Comment"),
+		);
+	}
+
+	/**
+	 * Returns the parent of the given node.
+	 * @param {JSONNode} node The node to get the parent of.
+	 * @returns {JSONNode|undefined} The parent of the node.
+	 */
+	getParent(node) {
+		return this.#parents.get(node);
+	}
+
+	/**
+	 * Gets all the ancestors of a given node
+	 * @param {JSONNode} node The node
+	 * @returns {Array<JSONNode>} All the ancestor nodes in the AST, not including the provided node, starting
+	 * from the root node at index 0 and going inwards to the parent node.
+	 * @throws {TypeError} When `node` is missing.
+	 */
+	getAncestors(node) {
+		if (!node) {
+			throw new TypeError("Missing required argument: node.");
+		}
+
+		const ancestorsStartingAtParent = [];
+
+		for (
+			let ancestor = this.#parents.get(node);
+			ancestor;
+			ancestor = this.#parents.get(ancestor)
+		) {
+			ancestorsStartingAtParent.push(ancestor);
+		}
+
+		return ancestorsStartingAtParent.reverse();
+	}
+
+	/**
+	 * Gets the source code for the given node.
+	 * @param {JSONNode} [node] The AST node to get the text for.
+	 * @param {number} [beforeCount] The number of characters before the node to retrieve.
+	 * @param {number} [afterCount] The number of characters after the node to retrieve.
+	 * @returns {string} The text representing the AST node.
+	 * @public
+	 */
+	getText(node, beforeCount, afterCount) {
+		if (node) {
+			return this.text.slice(
+				Math.max(node.range[0] - (beforeCount || 0), 0),
+				node.range[1] + (afterCount || 0),
+			);
+		}
+		return this.text;
+	}
+
+	/**
+	 * Gets the entire source text split into an array of lines.
+	 * @returns {Array} The source text as an array of lines.
+	 * @public
+	 */
+	get lines() {
+		if (!this.#lines) {
+			this.#lines = this.text.split(/\r?\n/gu);
+		}
+		return this.#lines;
+	}
+
+	/**
+	 * Traverse the source code and return the steps that were taken.
+	 * @returns {Iterable<TraversalStep>} The steps that were taken while traversing the source code.
+	 */
+	traverse() {
+		// Because the AST doesn't mutate, we can cache the steps
+		if (this.#steps) {
+			return this.#steps.values();
+		}
+
+		const steps = (this.#steps = []);
+
+		for (const { node, parent, phase } of momoa.iterator(
+			/** @type {DocumentNode} */ (this.ast),
+		)) {
+			this.#parents.set(node, parent);
+			steps.push(
+				new JSONTraversalStep({
+					target: /** @type {JSONNode & SyntaxElement} */ (node),
+					phase: phase === "enter" ? 1 : 2,
+					args: [node, parent],
+				}),
+			);
+		}
+
+		return steps;
+	}
+}
+
+/**
+ * @filedescription Functions to fix up rules to provide missing methods on the `context` object.
+ * @author Nicholas C. Zakas
+ */
+
+
+//-----------------------------------------------------------------------------
+// Types
+//-----------------------------------------------------------------------------
+
+
+//-----------------------------------------------------------------------------
+// Exports
+//-----------------------------------------------------------------------------
+
+/**
+ * JSON Language Object
+ * @implements {Language}
+ */
+class JSONLanguage {
+	/**
+	 * The type of file to read.
+	 * @type {"text"}
+	 */
+	fileType = "text";
+
+	/**
+	 * The line number at which the parser starts counting.
+	 * @type {0|1}
+	 */
+	lineStart = 1;
+
+	/**
+	 * The column number at which the parser starts counting.
+	 * @type {0|1}
+	 */
+	columnStart = 1;
+
+	/**
+	 * The name of the key that holds the type of the node.
+	 * @type {string}
+	 */
+	nodeTypeKey = "type";
+
+	/**
+	 * The parser mode.
+	 * @type {"json"|"jsonc"}
+	 */
+	#mode = "json";
+
+	/**
+	 * The visitor keys.
+	 * @type {Record<string, string[]>}
+	 */
+	visitorKeys = Object.fromEntries([...momoa.visitorKeys]);
+
+	/**
+	 * Creates a new instance.
+	 * @param {Object} options The options to use for this instance.
+	 * @param {"json"|"jsonc"} options.mode The parser mode to use.
+	 */
+	constructor({ mode }) {
+		this.#mode = mode;
+	}
+
+	/* eslint-disable class-methods-use-this, no-unused-vars -- Required to complete interface. */
+	/**
+	 * Validates the language options.
+	 * @param {Object} languageOptions The language options to validate.
+	 * @returns {void}
+	 * @throws {Error} When the language options are invalid.
+	 */
+	validateLanguageOptions(languageOptions) {
+		// no-op
+	}
+	/* eslint-enable class-methods-use-this, no-unused-vars -- Required to complete interface. */
+
+	/**
+	 * Parses the given file into an AST.
+	 * @param {File} file The virtual file to parse.
+	 * @returns {ParseResult} The result of parsing.
+	 */
+	parse(file) {
+		// Note: BOM already removed
+		const text = /** @type {string} */ (file.body);
+
+		/*
+		 * Check for parsing errors first. If there's a parsing error, nothing
+		 * else can happen. However, a parsing error does not throw an error
+		 * from this method - it's just considered a fatal error message, a
+		 * problem that ESLint identified just like any other.
+		 */
+		try {
+			const root = momoa.parse(text, {
+				mode: this.#mode,
+				ranges: true,
+				tokens: true,
+			});
+
+			return {
+				ok: true,
+				ast: /** @type {DocumentNode & SyntaxElement} */ (root),
+			};
+		} catch (ex) {
+			// error messages end with (line:column) so we strip that off for ESLint
+			const message = ex.message
+				.slice(0, ex.message.lastIndexOf("("))
+				.trim();
+
+			return {
+				ok: false,
+				errors: [
+					{
+						...ex,
+						message,
+					},
+				],
+			};
+		}
+	}
+
+	/* eslint-disable class-methods-use-this -- Required to complete interface. */
+	/**
+	 * Creates a new `JSONSourceCode` object from the given information.
+	 * @param {File} file The virtual file to create a `JSONSourceCode` object from.
+	 * @param {ParseResult} parseResult The result returned from `parse()`.
+	 * @returns {JSONSourceCode} The new `JSONSourceCode` object.
+	 */
+	createSourceCode(file, parseResult) {
+		return new JSONSourceCode({
+			text: /** @type {string} */ (file.body),
+			ast: parseResult.ast,
+		});
+	}
+	/* eslint-enable class-methods-use-this -- Required to complete interface. */
+}
+
+/**
+ * @fileoverview Rule to prevent duplicate keys in JSON.
+ * @author Nicholas C. Zakas
+ */
+
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+
+var noDuplicateKeys = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow duplicate keys in JSON objects",
+		},
+
+		messages: {
+			duplicateKey: 'Duplicate key "{{key}}" found.',
+		},
+	},
+
+	create(context) {
+		const objectKeys = [];
+		let keys;
+
+		return {
+			Object() {
+				objectKeys.push(keys);
+				keys = new Map();
+			},
+
+			Member(node) {
+				const key = node.name.value;
+
+				if (keys.has(key)) {
+					context.report({
+						loc: node.name.loc,
+						messageId: "duplicateKey",
+						data: {
+							key,
+						},
+					});
+				} else {
+					keys.set(key, node);
+				}
+			},
+			"Object:exit"() {
+				keys = objectKeys.pop();
+			},
+		};
+	},
+};
+
+/**
+ * @fileoverview Rule to prevent empty keys in JSON.
+ * @author Nicholas C. Zakas
+ */
+
+var noEmptyKeys = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow empty keys in JSON objects",
+		},
+
+		messages: {
+			emptyKey: "Empty key found.",
+		},
+	},
+
+	create(context) {
+		return {
+			Member(node) {
+				const key = node.name.value;
+
+				if (key.trim() === "") {
+					context.report({
+						loc: node.name.loc,
+						messageId: "emptyKey",
+					});
+				}
+			},
+		};
+	},
+};
+
+/**
+ * @fileoverview JSON plugin.
+ * @author Nicholas C. Zakas
+ */
+
+
+//-----------------------------------------------------------------------------
+// Plugin
+//-----------------------------------------------------------------------------
+
+const plugin = {
+	languages: {
+		json: new JSONLanguage({ mode: "json" }),
+		jsonc: new JSONLanguage({ mode: "jsonc" }),
+	},
+	rules: {
+		"no-duplicate-keys": noDuplicateKeys,
+		"no-empty-keys": noEmptyKeys,
+	},
+	configs: {},
+};
+
+Object.assign(plugin.configs, {
+	recommended: {
+		plugins: { json: plugin },
+		rules: {
+			"json/no-duplicate-keys": "error",
+			"json/no-empty-keys": "error",
+		},
+	},
+});
+
+module.exports = plugin;

package/dist/cjs/index.d.cts

@@ -0,0 +1,180 @@
+export { plugin as default };
+export type DocumentNode = import("@humanwhocodes/momoa").DocumentNode;
+export type JSONNode = import("@humanwhocodes/momoa").Node;
+export type JSONToken = import("@humanwhocodes/momoa").Token;
+export type SyntaxElement = import("@eslint/core").SyntaxElement;
+export type Language = import("@eslint/core").Language;
+export type File = import("@eslint/core").File;
+export type TraversalStep = import("@eslint/core").TraversalStep;
+export type VisitTraversalStep = import("@eslint/core").VisitTraversalStep;
+export type TextSourceCode = import("@eslint/core").TextSourceCode;
+export type ParseResult = import("@eslint/core").ParseResult;
+declare namespace plugin {
+    namespace languages {
+        let json: JSONLanguage;
+        let jsonc: JSONLanguage;
+    }
+    let rules: {
+        "no-duplicate-keys": {
+            meta: {
+                type: string;
+                docs: {
+                    description: string;
+                };
+                messages: {
+                    duplicateKey: string;
+                };
+            };
+            create(context: any): {
+                Object(): void;
+                Member(node: any): void;
+                "Object:exit"(): void;
+            };
+        };
+        "no-empty-keys": {
+            meta: {
+                type: string;
+                docs: {
+                    description: string;
+                };
+                messages: {
+                    emptyKey: string;
+                };
+            };
+            create(context: any): {
+                Member(node: any): void;
+            };
+        };
+    };
+    let configs: {};
+}
+/**
+ * @filedescription Functions to fix up rules to provide missing methods on the `context` object.
+ * @author Nicholas C. Zakas
+ */
+/**
+ * JSON Language Object
+ * @implements {Language}
+ */
+declare class JSONLanguage implements Language {
+    /**
+     * Creates a new instance.
+     * @param {Object} options The options to use for this instance.
+     * @param {"json"|"jsonc"} options.mode The parser mode to use.
+     */
+    constructor({ mode }: {
+        mode: "json" | "jsonc";
+    });
+    /**
+     * The type of file to read.
+     * @type {"text"}
+     */
+    fileType: "text";
+    /**
+     * The line number at which the parser starts counting.
+     * @type {0|1}
+     */
+    lineStart: 0 | 1;
+    /**
+     * The column number at which the parser starts counting.
+     * @type {0|1}
+     */
+    columnStart: 0 | 1;
+    /**
+     * The name of the key that holds the type of the node.
+     * @type {string}
+     */
+    nodeTypeKey: string;
+    /**
+     * The visitor keys.
+     * @type {Record<string, string[]>}
+     */
+    visitorKeys: Record<string, string[]>;
+    /**
+     * Validates the language options.
+     * @param {Object} languageOptions The language options to validate.
+     * @returns {void}
+     * @throws {Error} When the language options are invalid.
+     */
+    validateLanguageOptions(languageOptions: any): void;
+    /**
+     * Parses the given file into an AST.
+     * @param {File} file The virtual file to parse.
+     * @returns {ParseResult} The result of parsing.
+     */
+    parse(file: File): ParseResult;
+    /**
+     * Creates a new `JSONSourceCode` object from the given information.
+     * @param {File} file The virtual file to create a `JSONSourceCode` object from.
+     * @param {ParseResult} parseResult The result returned from `parse()`.
+     * @returns {JSONSourceCode} The new `JSONSourceCode` object.
+     */
+    createSourceCode(file: File, parseResult: ParseResult): JSONSourceCode;
+    #private;
+}
+/**
+ * JSON Source Code Object
+ * @implements {TextSourceCode}
+ */
+declare class JSONSourceCode implements TextSourceCode {
+    /**
+     * Creates a new instance.
+     * @param {Object} options The options for the instance.
+     * @param {string} options.text The source code text.
+     * @param {DocumentNode & SyntaxElement} options.ast The root AST node.
+     */
+    constructor({ text, ast }: {
+        text: string;
+        ast: DocumentNode & SyntaxElement;
+    });
+    /**
+     * The AST of the source code.
+     * @type {DocumentNode & SyntaxElement}
+     */
+    ast: DocumentNode & SyntaxElement;
+    /**
+     * The text of the source code.
+     * @type {string}
+     */
+    text: string;
+    /**
+     * The comment node in the source code.
+     * @type {Array<JSONToken>|undefined}
+     */
+    comments: Array<JSONToken> | undefined;
+    /**
+     * Returns the parent of the given node.
+     * @param {JSONNode} node The node to get the parent of.
+     * @returns {JSONNode|undefined} The parent of the node.
+     */
+    getParent(node: JSONNode): JSONNode | undefined;
+    /**
+     * Gets all the ancestors of a given node
+     * @param {JSONNode} node The node
+     * @returns {Array<JSONNode>} All the ancestor nodes in the AST, not including the provided node, starting
+     * from the root node at index 0 and going inwards to the parent node.
+     * @throws {TypeError} When `node` is missing.
+     */
+    getAncestors(node: JSONNode): Array<JSONNode>;
+    /**
+     * Gets the source code for the given node.
+     * @param {JSONNode} [node] The AST node to get the text for.
+     * @param {number} [beforeCount] The number of characters before the node to retrieve.
+     * @param {number} [afterCount] The number of characters after the node to retrieve.
+     * @returns {string} The text representing the AST node.
+     * @public
+     */
+    public getText(node?: JSONNode, beforeCount?: number, afterCount?: number): string;
+    /**
+     * Gets the entire source text split into an array of lines.
+     * @returns {Array} The source text as an array of lines.
+     * @public
+     */
+    public get lines(): any[];
+    /**
+     * Traverse the source code and return the steps that were taken.
+     * @returns {Iterable<TraversalStep>} The steps that were taken while traversing the source code.
+     */
+    traverse(): Iterable<TraversalStep>;
+    #private;
+}