@eslint/json 0.14.0 → 1.0.0

package/dist/rules/no-unsafe-values.js

@@ -0,0 +1,139 @@
+/**
+ * @fileoverview Rule to detect unsafe values in JSON.
+ * @author Bradley Meck Farias
+ */
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+/**
+ * @import { JSONRuleDefinition } from "../types.js";
+ * @typedef {"unsafeNumber"|"unsafeInteger"|"unsafeZero"|"subnormal"|"loneSurrogate"} NoUnsafeValuesMessageIds
+ * @typedef {JSONRuleDefinition<{ MessageIds: NoUnsafeValuesMessageIds }>} NoUnsafeValuesRuleDefinition
+ */
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+/*
+ * This rule is based on the JSON grammar from RFC 8259, section 6.
+ * https://tools.ietf.org/html/rfc8259#section-6
+ *
+ * Also, this rule is based on the JSON5 grammar from json5.org, section 6.
+ * https://spec.json5.org/#numbers
+ *
+ * We separately capture the integer and fractional parts of a number, so that
+ * we can check for unsafe numbers that will evaluate to Infinity.
+ */
+const NUMBER = /^[+-]?(?<int>0|([1-9]\d*))?(?:\.(?<frac>\d*))?(?:e[+-]?\d+)?$/iu;
+const NON_ZERO = /[1-9]/u;
+//-----------------------------------------------------------------------------
+// Rule Definition
+//-----------------------------------------------------------------------------
+/** @type {NoUnsafeValuesRuleDefinition} */
+const rule = {
+    meta: {
+        type: "problem",
+        docs: {
+            recommended: true,
+            description: "Disallow JSON values that are unsafe for interchange",
+            url: "https://github.com/eslint/json/tree/main/docs/rules/no-unsafe-values.md",
+        },
+        messages: {
+            unsafeNumber: "The number '{{ value }}' will evaluate to Infinity.",
+            unsafeInteger: "The integer '{{ value }}' is outside the safe integer range.",
+            unsafeZero: "The number '{{ value }}' will evaluate to zero.",
+            subnormal: "Unexpected subnormal number '{{ value }}' found, which may cause interoperability issues.",
+            loneSurrogate: "Lone surrogate '{{ surrogate }}' found.",
+        },
+    },
+    create(context) {
+        return {
+            Number(node) {
+                const value = context.sourceCode.getText(node);
+                if (Number.isFinite(node.value) !== true) {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "unsafeNumber",
+                        data: { value },
+                    });
+                }
+                else {
+                    // Also matches -0, intentionally
+                    if (node.value === 0) {
+                        // If the value has been rounded down to 0, but there was some
+                        // fraction or non-zero part before the e-, this is a very small
+                        // number that doesn't fit inside an f64.
+                        const match = value.match(NUMBER);
+                        if (match === null) {
+                            return;
+                        }
+                        // If any part of the number other than the exponent has a
+                        // non-zero digit in it, this number was not intended to be
+                        // evaluated down to a zero.
+                        if (NON_ZERO.test(match.groups.int) ||
+                            NON_ZERO.test(match.groups.frac)) {
+                            context.report({
+                                loc: node.loc,
+                                messageId: "unsafeZero",
+                                data: { value },
+                            });
+                        }
+                    }
+                    else if (!/[.e]/iu.test(value)) {
+                        // Intended to be an integer
+                        if (node.value > Number.MAX_SAFE_INTEGER ||
+                            node.value < Number.MIN_SAFE_INTEGER) {
+                            context.report({
+                                loc: node.loc,
+                                messageId: "unsafeInteger",
+                                data: { value },
+                            });
+                        }
+                    }
+                    else {
+                        // Floating point. Check for subnormal.
+                        const buffer = new ArrayBuffer(8);
+                        const view = new DataView(buffer);
+                        view.setFloat64(0, node.value, false);
+                        const asBigInt = view.getBigUint64(0, false);
+                        // Subnormals have an 11-bit exponent of 0 and a non-zero mantissa.
+                        if ((asBigInt & 0x7ff0000000000000n) === 0n) {
+                            context.report({
+                                loc: node.loc,
+                                messageId: "subnormal",
+                                // Value included so that it's seen in scientific notation
+                                data: {
+                                    value,
+                                },
+                            });
+                        }
+                    }
+                }
+            },
+            String(node) {
+                if (node.value.isWellFormed) {
+                    if (node.value.isWellFormed()) {
+                        return;
+                    }
+                }
+                // match any high surrogate and, if it exists, a paired low surrogate
+                // match any low surrogate not already matched
+                const surrogatePattern = /[\uD800-\uDBFF][\uDC00-\uDFFF]?|[\uDC00-\uDFFF]/gu;
+                /** @type {RegExpExecArray | null} */
+                let match;
+                while ((match = surrogatePattern.exec(node.value)) !== null) {
+                    // only need to report non-paired surrogates
+                    if (match[0].length < 2) {
+                        context.report({
+                            loc: node.loc,
+                            messageId: "loneSurrogate",
+                            data: {
+                                surrogate: JSON.stringify(match[0]).slice(1, -1),
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+export default rule;

package/dist/rules/sort-keys.d.ts

@@ -0,0 +1,34 @@
+export default rule;
+export type SortOptions = {
+    /**
+     * Whether key comparisons are case-sensitive.
+     */
+    caseSensitive: boolean;
+    /**
+     * Whether to use natural sort order instead of purely alphanumeric.
+     */
+    natural: boolean;
+    /**
+     * Minimum number of keys in an object before enforcing sorting.
+     */
+    minKeys: number;
+    /**
+     * Whether a blank line between properties starts a new group that is independently sorted.
+     */
+    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 DirectionName = "ascending" | "descending";
+export type SortName = "alphanumeric" | "natural";
+export type Sensitivity = "sensitive" | "insensitive";
+export type ComparatorMap = Record<DirectionName, Record<SortName, Record<Sensitivity, Comparator>>>;
+/** @type {SortKeysRuleDefinition} */
+declare const rule: SortKeysRuleDefinition;
+import type { JSONRuleDefinition } from "../types.js";

package/dist/rules/sort-keys.js

@@ -0,0 +1,185 @@
+/**
+ * @fileoverview Rule to require JSON object keys to be sorted.
+ * Copied largely from https://github.com/eslint/eslint/blob/main/lib/rules/sort-keys.js
+ * @author Robin Thomas
+ */
+//-----------------------------------------------------------------------------
+// Imports
+//-----------------------------------------------------------------------------
+import naturalCompare from "natural-compare";
+import { getKey, getRawKey } from "../util.js";
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+/**
+ * @import { JSONRuleDefinition } from "../types.js";
+ * @import { MemberNode } from "@humanwhocodes/momoa";
+ * @typedef {Object} SortOptions
+ * @property {boolean} caseSensitive Whether key comparisons are case-sensitive.
+ * @property {boolean} natural Whether to use natural sort order instead of purely alphanumeric.
+ * @property {number} minKeys Minimum number of keys in an object before enforcing sorting.
+ * @property {boolean} allowLineSeparatedGroups Whether a blank line between properties starts a new group that is independently sorted.
+ * @typedef {"sortKeys"} SortKeysMessageIds
+ * @typedef {"asc"|"desc"} SortDirection
+ * @typedef {[SortDirection, SortOptions]} SortKeysRuleOptions
+ * @typedef {JSONRuleDefinition<{ RuleOptions: SortKeysRuleOptions, MessageIds: SortKeysMessageIds }>} SortKeysRuleDefinition
+ * @typedef {(a:string,b:string) => boolean} Comparator
+ * @typedef {"ascending"|"descending"} DirectionName
+ * @typedef {"alphanumeric"|"natural"} SortName
+ * @typedef {"sensitive"|"insensitive"} Sensitivity
+ * @typedef {Record<DirectionName, Record<SortName, Record<Sensitivity, Comparator>>>} ComparatorMap
+ */
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+const hasNonWhitespace = /\S/u;
+/** @type {ComparatorMap} */
+const comparators = {
+    ascending: {
+        alphanumeric: {
+            sensitive: (a, b) => a <= b,
+            insensitive: (a, b) => a.toLowerCase() <= b.toLowerCase(),
+        },
+        natural: {
+            sensitive: (a, b) => naturalCompare(a, b) <= 0,
+            insensitive: (a, b) => naturalCompare(a.toLowerCase(), b.toLowerCase()) <= 0,
+        },
+    },
+    descending: {
+        alphanumeric: {
+            sensitive: (a, b) => comparators.ascending.alphanumeric.sensitive(b, a),
+            insensitive: (a, b) => comparators.ascending.alphanumeric.insensitive(b, a),
+        },
+        natural: {
+            sensitive: (a, b) => comparators.ascending.natural.sensitive(b, a),
+            insensitive: (a, b) => comparators.ascending.natural.insensitive(b, a),
+        },
+    },
+};
+//-----------------------------------------------------------------------------
+// Rule Definition
+//-----------------------------------------------------------------------------
+/** @type {SortKeysRuleDefinition} */
+const rule = {
+    meta: {
+        type: "suggestion",
+        defaultOptions: [
+            "asc",
+            {
+                allowLineSeparatedGroups: false,
+                caseSensitive: true,
+                minKeys: 2,
+                natural: false,
+            },
+        ],
+        docs: {
+            recommended: false,
+            description: `Require JSON object keys to be sorted`,
+            url: "https://github.com/eslint/json/tree/main/docs/rules/sort-keys.md",
+        },
+        messages: {
+            sortKeys: "Expected object keys to be in {{sortName}} case-{{sensitivity}} {{direction}} order. '{{thisName}}' should be before '{{prevName}}'.",
+        },
+        schema: [
+            {
+                enum: ["asc", "desc"],
+            },
+            {
+                type: "object",
+                properties: {
+                    caseSensitive: {
+                        type: "boolean",
+                    },
+                    natural: {
+                        type: "boolean",
+                    },
+                    minKeys: {
+                        type: "integer",
+                        minimum: 2,
+                    },
+                    allowLineSeparatedGroups: {
+                        type: "boolean",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const { sourceCode } = context;
+        const [directionShort, { allowLineSeparatedGroups, caseSensitive, natural, minKeys },] = context.options;
+        /** @type {DirectionName} */
+        const direction = directionShort === "asc" ? "ascending" : "descending";
+        /** @type {SortName} */
+        const sortName = natural ? "natural" : "alphanumeric";
+        /** @type {Sensitivity} */
+        const sensitivity = caseSensitive ? "sensitive" : "insensitive";
+        /** @type {Comparator} */
+        const isValidOrder = comparators[direction][sortName][sensitivity];
+        // Note that @humanwhocodes/momoa doesn't include comments in the object.members tree, so we can't just see if a member is preceded by a comment
+        const commentLineNums = new Set();
+        for (const comment of sourceCode.comments) {
+            for (let lineNum = comment.loc.start.line; lineNum <= comment.loc.end.line; lineNum += 1) {
+                commentLineNums.add(lineNum);
+            }
+        }
+        /**
+         * Checks if two members are line-separated.
+         * @param {MemberNode} prevMember The previous member.
+         * @param {MemberNode} member The current member.
+         * @returns {boolean} True if the members are separated by at least one blank line (ignoring comment-only lines).
+         */
+        function isLineSeparated(prevMember, member) {
+            // Note that there can be comments *inside* members, e.g. `{"foo: /* comment *\/ "bar"}`, but these are ignored when calculating line-separated groups
+            const prevMemberEndLine = prevMember.loc.end.line;
+            const thisStartLine = member.loc.start.line;
+            if (thisStartLine - prevMemberEndLine < 2) {
+                return false;
+            }
+            for (let lineNum = prevMemberEndLine + 1; lineNum < thisStartLine; lineNum += 1) {
+                if (!commentLineNums.has(lineNum) &&
+                    !hasNonWhitespace.test(sourceCode.lines[lineNum - 1])) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return {
+            Object(node) {
+                /** @type {MemberNode} */
+                let prevMember;
+                /** @type {string} */
+                let prevName;
+                /** @type {string} */
+                let prevRawName;
+                if (node.members.length < minKeys) {
+                    return;
+                }
+                for (const member of node.members) {
+                    const thisName = getKey(member);
+                    const thisRawName = getRawKey(member, sourceCode);
+                    if (prevMember &&
+                        !isValidOrder(prevName, thisName) &&
+                        (!allowLineSeparatedGroups ||
+                            !isLineSeparated(prevMember, member))) {
+                        context.report({
+                            loc: member.name.loc,
+                            messageId: "sortKeys",
+                            data: {
+                                thisName: thisRawName,
+                                prevName: prevRawName,
+                                direction,
+                                sensitivity,
+                                sortName,
+                            },
+                        });
+                    }
+                    prevMember = member;
+                    prevName = thisName;
+                    prevRawName = thisRawName;
+                }
+            },
+        };
+    },
+};
+export default rule;

package/dist/rules/top-level-interop.d.ts

@@ -0,0 +1,17 @@
+export default rule;
+export type TopLevelInteropMessageIds = "topLevel";
+export type TopLevelInteropRuleDefinition = JSONRuleDefinition<{
+    MessageIds: TopLevelInteropMessageIds;
+}>;
+/**
+ * @fileoverview Rule to ensure top-level items are either an array or object.
+ * @author Joe Hildebrand
+ */
+/**
+ * @import { JSONRuleDefinition } from "../types.js";
+ * @typedef {"topLevel"} TopLevelInteropMessageIds
+ * @typedef {JSONRuleDefinition<{ MessageIds: TopLevelInteropMessageIds }>} TopLevelInteropRuleDefinition
+ */
+/** @type {TopLevelInteropRuleDefinition} */
+declare const rule: TopLevelInteropRuleDefinition;
+import type { JSONRuleDefinition } from "../types.js";

package/dist/rules/top-level-interop.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Rule to ensure top-level items are either an array or object.
+ * @author Joe Hildebrand
+ */
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+/**
+ * @import { JSONRuleDefinition } from "../types.js";
+ * @typedef {"topLevel"} TopLevelInteropMessageIds
+ * @typedef {JSONRuleDefinition<{ MessageIds: TopLevelInteropMessageIds }>} TopLevelInteropRuleDefinition
+ */
+//-----------------------------------------------------------------------------
+// Rule Definition
+//-----------------------------------------------------------------------------
+/** @type {TopLevelInteropRuleDefinition} */
+const rule = {
+    meta: {
+        type: "problem",
+        docs: {
+            recommended: false,
+            description: "Require the JSON top-level value to be an array or object",
+            url: "https://github.com/eslint/json/tree/main/docs/rules/top-level-interop.md",
+        },
+        messages: {
+            topLevel: "Top level item should be array or object, got '{{type}}'.",
+        },
+    },
+    create(context) {
+        return {
+            Document(node) {
+                const { type } = node.body;
+                if (type !== "Object" && type !== "Array") {
+                    context.report({
+                        loc: node.loc,
+                        messageId: "topLevel",
+                        data: { type },
+                    });
+                }
+            },
+        };
+    },
+};
+export default rule;

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Additional types for this package.
+ * @author Nicholas C. Zakas
+ */
+export {};

package/dist/util.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Utility Library
+ * @author 루밀LuMir(lumirlumir)
+ */
+/**
+ * @import { MemberNode } from "@humanwhocodes/momoa";
+ * @import { JSONSourceCode } from "./languages/json-source-code.js";
+ */
+/**
+ * Gets the `MemberNode`'s key value.
+ * @param {MemberNode} node The node to get the key from.
+ * @returns {string} The key value.
+ */
+export function getKey(node: MemberNode): string;
+/**
+ * Gets the `MemberNode`'s raw key value.
+ * @param {MemberNode} node The node to get the raw key from.
+ * @param {JSONSourceCode} sourceCode The JSON source code object.
+ * @returns {string} The raw key value.
+ */
+export function getRawKey(node: MemberNode, sourceCode: JSONSourceCode): string;
+import type { MemberNode } from "@humanwhocodes/momoa";
+import type { JSONSourceCode } from "./languages/json-source-code.js";

package/dist/util.js

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview Utility Library
+ * @author 루밀LuMir(lumirlumir)
+ */
+//-----------------------------------------------------------------------------
+// Type Definitions
+//-----------------------------------------------------------------------------
+/**
+ * @import { MemberNode } from "@humanwhocodes/momoa";
+ * @import { JSONSourceCode } from "./languages/json-source-code.js";
+ */
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+/**
+ * Gets the `MemberNode`'s key value.
+ * @param {MemberNode} node The node to get the key from.
+ * @returns {string} The key value.
+ */
+export function getKey(node) {
+    return node.name.type === "String" ? node.name.value : node.name.name;
+}
+/**
+ * Gets the `MemberNode`'s raw key value.
+ * @param {MemberNode} node The node to get the raw key from.
+ * @param {JSONSourceCode} sourceCode The JSON source code object.
+ * @returns {string} The raw key value.
+ */
+export function getRawKey(node, sourceCode) {
+    return node.name.type === "String"
+        ? sourceCode.getText(node.name, -1, -1)
+        : sourceCode.getText(node.name);
+}

package/package.json

@@ -1,29 +1,15 @@
 {
   "name": "@eslint/json",
-  "version": "0.14.0",
+  "version": "1.0.0",
   "description": "JSON linting plugin for ESLint",
   "author": "Nicholas C. Zakas",
   "type": "module",
-  "main": "dist/esm/index.js",
-  "types": "dist/esm/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "require": {
-        "types": "./dist/cjs/index.d.cts",
-        "default": "./dist/cjs/index.cjs"
-      },
-      "import": {
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.js"
-      }
-    },
-    "./types": {
-      "require": {
-        "types": "./dist/cjs/types.cts"
-      },
-      "import": {
-        "types": "./dist/esm/types.d.ts"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
   "files": [
@@ -41,10 +27,7 @@
       "prettier --write"
     ],
     "!(*.js)": "prettier --write --ignore-unknown",
-    "README.md": [
-      "npm run build:update-rules-docs"
-    ],
-    "{src/rules/*.js,tools/update-rules-docs.js}": [
+    "{src/rules/*.js,tools/update-rules-docs.js,README.md}": [
       "npm run build:update-rules-docs",
       "git add README.md"
     ]
@@ -58,20 +41,20 @@
   },
   "homepage": "https://github.com/eslint/json#readme",
   "scripts": {
-    "build:dedupe-types": "node tools/dedupe-types.js dist/cjs/index.cjs dist/esm/index.js",
-    "build:cts": "node tools/build-cts.js",
+    "build": "npm run build:rules && npm run build:types && npm run build:update-rules-docs",
     "build:rules": "node tools/build-rules.js",
-    "build": "npm run build:rules && rollup -c && npm run build:dedupe-types && tsc -p tsconfig.esm.json && npm run build:cts",
+    "build:types": "tsc",
     "build:update-rules-docs": "node tools/update-rules-docs.js",
     "prepare": "npm run build",
     "pretest": "npm run build",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
+    "lint:types": "attw --pack --profile esm-only",
     "fmt": "prettier --write .",
     "fmt:check": "prettier --check .",
     "test": "mocha \"tests/**/*.test.js\"",
     "test:coverage": "c8 npm test",
-    "test:jsr": "npx jsr@latest publish --dry-run",
+    "test:jsr": "npx -y jsr@latest publish --dry-run",
     "test:types": "tsc -p tests/types/tsconfig.json"
   },
   "keywords": [
@@ -83,28 +66,27 @@
   ],
   "license": "Apache-2.0",
   "dependencies": {
-    "@eslint/core": "^0.17.0",
-    "@eslint/plugin-kit": "^0.4.1",
+    "@eslint/core": "^1.0.1",
+    "@eslint/plugin-kit": "^0.5.1",
     "@humanwhocodes/momoa": "^3.3.10",
     "natural-compare": "^1.4.0"
   },
   "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
     "c8": "^10.1.3",
     "dedent": "^1.5.3",
-    "eslint": "^9.36.0",
+    "eslint": "^9.39.2",
     "eslint-config-eslint": "^13.0.0",
     "eslint-plugin-eslint-plugin": "^6.3.2",
-    "lint-staged": "^15.2.7",
+    "globals": "^17.0.0",
+    "lint-staged": "^16.0.0",
     "mdast-util-from-markdown": "^2.0.2",
     "mocha": "^11.3.0",
-    "prettier": "^3.4.1",
-    "rollup": "^4.52.3",
-    "rollup-plugin-copy": "^3.5.0",
-    "rollup-plugin-delete": "^3.0.1",
+    "prettier": "3.8.1",
     "typescript": "^5.9.2",
     "yorkie": "^2.0.0"
   },
   "engines": {
-    "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+    "node": "^20.19.0 || ^22.13.0 || >=24"
   }
 }