@eslint/json 0.10.0 → 0.12.0

package/dist/cjs/index.d.cts

@@ -1,38 +1,64 @@
-export type DocumentNode = import("@humanwhocodes/momoa").DocumentNode;
-export type JSONNode = import("@humanwhocodes/momoa").Node;
-export type JSONToken = import("@humanwhocodes/momoa").Token;
-export type SourceRange = import("@eslint/core").SourceRange;
-export type SourceLocation = import("@eslint/core").SourceLocation;
-export type File = import("@eslint/core").File;
-export type TraversalStep = import("@eslint/core").TraversalStep;
-export type TextSourceCode = import("@eslint/core").TextSourceCode;
-export type VisitTraversalStep = import("@eslint/core").VisitTraversalStep;
-export type FileProblem = import("@eslint/core").FileProblem;
-export type DirectiveType = import("@eslint/core").DirectiveType;
-export type RulesConfig = import("@eslint/core").RulesConfig;
-export type Language = import("@eslint/core").Language;
-export type OkParseResult = import("@eslint/core").OkParseResult<DocumentNode>;
-export type ParseResult = import("@eslint/core").ParseResult<DocumentNode>;
+export type JSONOkParseResult = OkParseResult<DocumentNode>;
+export type JSONParseResult = ParseResult<DocumentNode>;
 export type JSONLanguageOptions = {
     /**
-     * Whether to allow trailing commas.
+     * Whether to allow trailing commas in JSONC mode.
      */
     allowTrailingCommas?: boolean;
 };
+export type NoDuplicateKeysMessageIds = "duplicateKey";
+export type NoDuplicateKeysRuleDefinition = JSONRuleDefinition<{
+    MessageIds: NoDuplicateKeysMessageIds;
+}>;
+export type NoEmptyKeysMessageIds = "emptyKey";
+export type NoEmptyKeysRuleDefinition = JSONRuleDefinition<{
+    MessageIds: NoEmptyKeysMessageIds;
+}>;
+export type NoUnsafeValuesMessageIds = "unsafeNumber" | "unsafeInteger" | "unsafeZero" | "subnormal" | "loneSurrogate";
+export type NoUnsafeValuesRuleDefinition = JSONRuleDefinition<{
+    MessageIds: NoUnsafeValuesMessageIds;
+}>;
+export type NoUnnormalizedKeysMessageIds = "unnormalizedKey";
+export type NoUnnormalizedKeysOptions = {
+    form: string;
+};
+export type NoUnnormalizedKeysRuleDefinition = JSONRuleDefinition<{
+    RuleOptions: [NoUnnormalizedKeysOptions];
+    MessageIds: NoUnnormalizedKeysMessageIds;
+}>;
+export type SortOptions = {
+    caseSensitive: boolean;
+    natural: boolean;
+    minKeys: number;
+    allowLineSeparatedGroups: boolean;
+};
+export type SortKeysMessageIds = "sortKeys";
+export type SortDirection = "asc" | "desc";
+export type SortKeysRuleOptions = [SortDirection, SortOptions];
+export type SortKeysRuleDefinition = JSONRuleDefinition<{
+    RuleOptions: SortKeysRuleOptions;
+    MessageIds: SortKeysMessageIds;
+}>;
+export type Comparator = (a: string, b: string) => boolean;
+export type TopLevelInteropMessageIds = "topLevel";
+export type TopLevelInteropRuleDefinition = JSONRuleDefinition<{
+    MessageIds: TopLevelInteropMessageIds;
+}>;
 /**
  * @filedescription Functions to fix up rules to provide missing methods on the `context` object.
  * @author Nicholas C. Zakas
  */
-/** @typedef {import("@eslint/core").Language} Language */
-/** @typedef {import("@eslint/core").OkParseResult<DocumentNode>} OkParseResult */
-/** @typedef {import("@eslint/core").ParseResult<DocumentNode>} ParseResult */
 /**
+ *
+ * @typedef {OkParseResult<DocumentNode>} JSONOkParseResult
+ * @typedef {ParseResult<DocumentNode>} JSONParseResult
+ *
  * @typedef {Object} JSONLanguageOptions
- * @property {boolean} [allowTrailingCommas] Whether to allow trailing commas.
+ * @property {boolean} [allowTrailingCommas] Whether to allow trailing commas in JSONC mode.
  */
 /**
  * JSON Language Object
- * @implements {Language}
+ * @implements {Language<{ LangOptions: JSONLanguageOptions; Code: JSONSourceCode; RootNode: DocumentNode; Node: AnyNode }>}
  */
 export class JSONLanguage implements Language {
     /**
@@ -79,24 +105,25 @@ export class JSONLanguage implements Language {
      * Parses the given file into an AST.
      * @param {File} file The virtual file to parse.
      * @param {{languageOptions: JSONLanguageOptions}} context The options to use for parsing.
-     * @returns {ParseResult} The result of parsing.
+     * @returns {JSONParseResult} The result of parsing.
      */
     parse(file: File, context: {
         languageOptions: JSONLanguageOptions;
-    }): ParseResult;
+    }): JSONParseResult;
     /**
      * Creates a new `JSONSourceCode` object from the given information.
      * @param {File} file The virtual file to create a `JSONSourceCode` object from.
-     * @param {OkParseResult} parseResult The result returned from `parse()`.
+     * @param {JSONOkParseResult} parseResult The result returned from `parse()`.
      * @returns {JSONSourceCode} The new `JSONSourceCode` object.
      */
-    createSourceCode(file: File, parseResult: OkParseResult): JSONSourceCode;
+    createSourceCode(file: File, parseResult: JSONOkParseResult): JSONSourceCode;
     #private;
 }
 /**
  * JSON Source Code Object
+ * @implements {TextSourceCode<{LangOptions: JSONLanguageOptions, RootNode: DocumentNode, SyntaxElementWithLoc: JSONSyntaxElement, ConfigNode: Token}>}
  */
-export class JSONSourceCode extends TextSourceCodeBase {
+export class JSONSourceCode extends TextSourceCodeBase implements TextSourceCode {
     /**
      * Creates a new instance.
      * @param {Object} options The options for the instance.
@@ -114,15 +141,15 @@ export class JSONSourceCode extends TextSourceCodeBase {
     ast: DocumentNode;
     /**
      * The comment node in the source code.
-     * @type {Array<JSONToken>|undefined}
+     * @type {Array<Token>|undefined}
      */
-    comments: Array<JSONToken> | undefined;
+    comments: Array<Token> | undefined;
     /**
      * Returns an array of all inline configuration nodes found in the
      * source code.
-     * @returns {Array<JSONToken>} An array of all inline configuration nodes.
+     * @returns {Array<Token>} An array of all inline configuration nodes.
      */
-    getInlineConfigNodes(): Array<JSONToken>;
+    getInlineConfigNodes(): Array<Token>;
     /**
      * Returns directives that enable or disable rules along with any problems
      * encountered while parsing the directives.
@@ -150,10 +177,10 @@ export class JSONSourceCode extends TextSourceCodeBase {
     };
     /**
      * 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.
+     * @param {Node} node The node to get the parent of.
+     * @returns {Node|undefined} The parent of the node.
      */
-    getParent(node: JSONNode): JSONNode | undefined;
+    getParent(node: Node): Node | undefined;
     /**
      * Traverse the source code and return the steps that were taken.
      * @returns {Iterable<JSONTraversalStep>} The steps that were taken while traversing the source code.
@@ -172,137 +199,12 @@ declare namespace plugin {
         let json5: JSONLanguage;
     }
     let rules: {
-        "no-duplicate-keys": {
-            meta: {
-                type: "problem";
-                docs: {
-                    description: string;
-                };
-                messages: {
-                    duplicateKey: string;
-                };
-            };
-            create(context: any): {
-                Object(): void;
-                Member(node: any): void;
-                "Object:exit"(): void;
-            };
-        };
-        "no-empty-keys": {
-            meta: {
-                type: "problem";
-                docs: {
-                    description: string;
-                };
-                messages: {
-                    emptyKey: string;
-                };
-            };
-            create(context: any): {
-                Member(node: any): void;
-            };
-        };
-        "no-unsafe-values": {
-            meta: {
-                type: "problem";
-                docs: {
-                    description: string;
-                };
-                messages: {
-                    unsafeNumber: string;
-                    unsafeInteger: string;
-                    unsafeZero: string;
-                    subnormal: string;
-                    loneSurrogate: string;
-                };
-            };
-            create(context: any): {
-                Number(node: any): void;
-                String(node: any): void;
-            };
-        };
-        "no-unnormalized-keys": {
-            meta: {
-                type: "problem";
-                docs: {
-                    description: string;
-                };
-                messages: {
-                    unnormalizedKey: string;
-                };
-                schema: {
-                    type: string;
-                    properties: {
-                        form: {
-                            enum: string[];
-                        };
-                    };
-                    additionalProperties: boolean;
-                }[];
-            };
-            create(context: any): {
-                Member(node: any): void;
-            };
-        };
-        "sort-keys": {
-            meta: {
-                type: "suggestion";
-                defaultOptions: (string | {
-                    allowLineSeparatedGroups: boolean;
-                    caseSensitive: boolean;
-                    minKeys: number;
-                    natural: boolean;
-                })[];
-                docs: {
-                    description: string;
-                };
-                messages: {
-                    sortKeys: string;
-                };
-                schema: ({
-                    enum: string[];
-                    type?: undefined;
-                    properties?: undefined;
-                    additionalProperties?: undefined;
-                } | {
-                    type: string;
-                    properties: {
-                        caseSensitive: {
-                            type: string;
-                        };
-                        natural: {
-                            type: string;
-                        };
-                        minKeys: {
-                            type: string;
-                            minimum: number;
-                        };
-                        allowLineSeparatedGroups: {
-                            type: string;
-                        };
-                    };
-                    additionalProperties: boolean;
-                    enum?: undefined;
-                })[];
-            };
-            create(context: any): {
-                Object(node: any): void;
-            };
-        };
-        "top-level-interop": {
-            meta: {
-                type: "problem";
-                docs: {
-                    description: string;
-                };
-                messages: {
-                    topLevel: string;
-                };
-            };
-            create(context: any): {
-                Document(node: any): void;
-            };
-        };
+        "no-duplicate-keys": NoDuplicateKeysRuleDefinition;
+        "no-empty-keys": NoEmptyKeysRuleDefinition;
+        "no-unsafe-values": NoUnsafeValuesRuleDefinition;
+        "no-unnormalized-keys": NoUnnormalizedKeysRuleDefinition;
+        "sort-keys": SortKeysRuleDefinition;
+        "top-level-interop": TopLevelInteropRuleDefinition;
     };
     namespace configs {
         namespace recommended {
@@ -317,8 +219,20 @@ declare namespace plugin {
         }
     }
 }
+import type { DocumentNode } from "@humanwhocodes/momoa";
+import type { OkParseResult } from "@eslint/core";
+import type { ParseResult } from "@eslint/core";
+import type { JSONRuleDefinition } from "./types.cts";
+import type { Language } from "@eslint/core";
+import type { File } from "@eslint/core";
+import type { TextSourceCode } from "@eslint/core";
 import { TextSourceCodeBase } from '@eslint/plugin-kit';
+import type { Token } from "@humanwhocodes/momoa";
+import type { FileProblem } from "@eslint/core";
 import { Directive } from '@eslint/plugin-kit';
+import type { RulesConfig } from "@eslint/core";
+import type { SourceLocation } from "@eslint/core";
+import type { Node } from "@humanwhocodes/momoa";
 /**
  * A class to represent a step in the traversal process.
  */
@@ -326,20 +240,20 @@ declare class JSONTraversalStep extends VisitNodeStep {
     /**
      * Creates a new instance.
      * @param {Object} options The options for the step.
-     * @param {JSONNode} options.target The target of the step.
+     * @param {Node} 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 }: {
-        target: JSONNode;
+        target: Node;
         phase: 1 | 2;
         args: Array<any>;
     });
     /**
      * The target of the step.
-     * @type {JSONNode}
+     * @type {Node}
      */
-    target: JSONNode;
+    target: Node;
 }
 import { VisitNodeStep } from '@eslint/plugin-kit';
 export { plugin as default };

package/dist/cjs/types.cts

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Additional types for this package.
+ * @author Nicholas C. Zakas
+ */
+
+//------------------------------------------------------------------------------
+// Imports
+//------------------------------------------------------------------------------
+
+import type { RuleVisitor, RuleDefinition } from "@eslint/core";
+import type {
+	DocumentNode,
+	MemberNode,
+	ElementNode,
+	ObjectNode,
+	ArrayNode,
+	StringNode,
+	NullNode,
+	NumberNode,
+	BooleanNode,
+	NaNNode,
+	InfinityNode,
+	IdentifierNode,
+	AnyNode,
+	Token,
+} from "@humanwhocodes/momoa";
+import type { JSONLanguageOptions, JSONSourceCode } from "./index.cjs";
+
+//------------------------------------------------------------------------------
+// Types
+//------------------------------------------------------------------------------
+
+type ValueNodeParent = DocumentNode | MemberNode | ElementNode;
+
+/**
+ * A JSON syntax element, including nodes and tokens.
+ */
+export type JSONSyntaxElement = Token | AnyNode;
+
+/**
+ * The visitor format returned from rules in this package.
+ */
+export interface JSONRuleVisitor extends RuleVisitor {
+	Document?(node: DocumentNode): void;
+	Member?(node: MemberNode, parent?: ObjectNode): void;
+	Element?(node: ElementNode, parent?: ArrayNode): void;
+	Object?(node: ObjectNode, parent?: ValueNodeParent): void;
+	Array?(node: ArrayNode, parent?: ValueNodeParent): void;
+	String?(node: StringNode, parent?: ValueNodeParent): void;
+	Null?(node: NullNode, parent?: ValueNodeParent): void;
+	Number?(node: NumberNode, parent?: ValueNodeParent): void;
+	Boolean?(node: BooleanNode, parent?: ValueNodeParent): void;
+	NaN?(node: NaNNode, parent?: ValueNodeParent): void;
+	Infinity?(node: InfinityNode, parent?: ValueNodeParent): void;
+	Identifier?(node: IdentifierNode, parent?: ValueNodeParent): void;
+
+	"Document:exit"?(node: DocumentNode): void;
+	"Member:exit"?(node: MemberNode, parent?: ObjectNode): void;
+	"Element:exit"?(node: ElementNode, parent?: ArrayNode): void;
+	"Object:exit"?(node: ObjectNode, parent?: ValueNodeParent): void;
+	"Array:exit"?(node: ArrayNode, parent?: ValueNodeParent): void;
+	"String:exit"?(node: StringNode, parent?: ValueNodeParent): void;
+	"Null:exit"?(node: NullNode, parent?: ValueNodeParent): void;
+	"Number:exit"?(node: NumberNode, parent?: ValueNodeParent): void;
+	"Boolean:exit"?(node: BooleanNode, parent?: ValueNodeParent): void;
+	"NaN:exit"?(node: NaNNode, parent?: ValueNodeParent): void;
+	"Infinity:exit"?(node: InfinityNode, parent?: ValueNodeParent): void;
+	"Identifier:exit"?(node: IdentifierNode, parent?: ValueNodeParent): void;
+}
+
+export type JSONRuleDefinitionTypeOptions = {
+	RuleOptions: unknown[];
+	MessageIds: string;
+	ExtRuleDocs: Record<string, unknown>;
+};
+
+export type JSONRuleDefinition<
+	Options extends Partial<JSONRuleDefinitionTypeOptions> = {},
+> = RuleDefinition<
+	// Language specific type options (non-configurable)
+	{
+		LangOptions: JSONLanguageOptions;
+		Code: JSONSourceCode;
+		Visitor: JSONRuleVisitor;
+		Node: AnyNode;
+	} & Required<
+		// Rule specific type options (custom)
+		Options &
+			// Rule specific type options (defaults)
+			Omit<JSONRuleDefinitionTypeOptions, keyof Options>
+	>
+>;