@amritk/lint 0.7.1 → 0.8.0

package/dist/index.js

@@ -2,7 +2,7 @@ import { createBoundedCache, createRuleset as createCoreRuleset, lintWithResult
 import { createFixPlugin, FIX_PLUGIN_NAME } from "./fix/index.js";
 import { builtinFunctions } from "./functions/index.js";
 import { collectCustomFunctions, resolveRulesetFile } from "./ruleset-files.js";
-import { compileQuery, createDocument, createLinter, detectFormats, globToRegExp, lint, lintWithResult as lintWithResult2, matchesGlob, pointerToPath, query, queryCompiled, queryMany, resolveSourceOrigin, resolveSourceOriginFromMap, resolveSourcePath, runPlugins, validateRuleset } from "./core/index.js";
+import { compileQuery, createDocument, createDocumentFromData, createLinter, detectFormats, globToRegExp, lint, lintWithResult as lintWithResult2, matchesGlob, pointerToPath, query, queryCompiled, queryMany, resolveSourceOrigin, resolveSourceOriginFromMap, resolveSourcePath, runPlugins, validateRuleset } from "./core/index.js";
 import { applyFixes, createFixPlugin as createFixPlugin2, FIX_PLUGIN_NAME as FIX_PLUGIN_NAME2 } from "./fix/index.js";
 import { alphabetical, builtinFunctions as builtinFunctions2, casing, defined, enumeration, falsy, length, or, pattern, schema, truthy, typedEnum, undefinedFn, unreferencedReusableObject, xor } from "./functions/index.js";
 import { detectFormat, parseWithPointers } from "./parsers/index.js";
@@ -115,6 +115,7 @@ export {
   casing,
   compileQuery,
   createDocument,
+  createDocumentFromData,
   createFixPlugin2 as createFixPlugin,
   createLinter,
   createRuleset,

package/dist/parsers/depth.js

@@ -1,23 +1,27 @@
 const MAX_NESTING_DEPTH = 1e3;
 const findExcessiveNesting = (source, limit = MAX_NESTING_DEPTH) => {
+  const length = source.length;
   let depth = 0;
-  let inString = false;
-  for (let i = 0; i < source.length; i++) {
-    const ch = source[i];
-    if (inString) {
-      if (ch === "\\")
-        i++;
-      else if (ch === '"')
-        inString = false;
-      continue;
-    }
-    if (ch === '"')
-      inString = true;
-    else if (ch === "{" || ch === "[") {
+  for (let i = 0; i < length; i++) {
+    const code = source.charCodeAt(i);
+    if (code === 34) {
+      let close = source.indexOf('"', i + 1);
+      while (close !== -1) {
+        let slashes = 0;
+        for (let j = close - 1; source.charCodeAt(j) === 92; j--)
+          slashes++;
+        if ((slashes & 1) === 0)
+          break;
+        close = source.indexOf('"', close + 1);
+      }
+      if (close === -1)
+        return -1;
+      i = close;
+    } else if (code === 123 || code === 91) {
       depth++;
       if (depth > limit)
         return i;
-    } else if (ch === "}" || ch === "]")
+    } else if (code === 125 || code === 93)
       depth--;
   }
   return -1;

package/dist/parsers/index.d.ts

@@ -1,6 +1,7 @@
 export { findExcessiveNesting, MAX_NESTING_DEPTH } from './depth.js';
 export { type ApplyEditOpsResult, applyEditOps, applyEditOpsWithChanges, type EditOp } from './edit-model.js';
 export { parseJson } from './json.js';
+export { createJsonLocator } from './json-locator.js';
 export { createLineMap, type LineMap } from './lines.js';
 export { DiagnosticSeverity, type IDiagnostic, type ILocation, type IParseResult, type IParserOptions, type IPosition, type IRange, type JsonPath, } from './types.js';
 export { parseYaml } from './yaml.js';

package/dist/parsers/index.js

@@ -1,6 +1,7 @@
 import { findExcessiveNesting, MAX_NESTING_DEPTH } from "./depth.js";
 import { applyEditOps, applyEditOpsWithChanges } from "./edit-model.js";
 import { parseJson } from "./json.js";
+import { createJsonLocator } from "./json-locator.js";
 import { createLineMap } from "./lines.js";
 import { DiagnosticSeverity } from "./types.js";
 import { parseYaml } from "./yaml.js";
@@ -19,6 +20,7 @@ export {
   MAX_NESTING_DEPTH,
   applyEditOps,
   applyEditOpsWithChanges,
+  createJsonLocator,
   createLineMap,
   detectFormat,
   findExcessiveNesting,

package/dist/parsers/json-locator.d.ts

@@ -0,0 +1,19 @@
+import { type LineMap } from './lines.js';
+import type { ILocation, JsonPath } from './types.js';
+/**
+ * Resolves JSON paths to source ranges by scanning `source` on demand. The
+ * source is expected to be valid JSON; text that is not still gets an answer
+ * (and never a hang or a throw), just not a meaningful one.
+ *
+ * The eager alternative builds a node for every value in the document before
+ * the first lookup, which on a 25 MB spec costs several times the
+ * `JSON.parse` that produced the data. A lint run only asks for the handful
+ * of paths that carry findings, so this indexes just the containers a lookup
+ * passes through, once each: a container's members are listed the first time
+ * any lookup enters it, and every later lookup through it is a map read.
+ *
+ * Ranges are the ones a `jsonc-parser` tree gives for the same path: a
+ * string's range includes its quotes, a container's its brackets, and among
+ * duplicate keys the first one is found.
+ */
+export declare const createJsonLocator: (source: string, lineMap?: LineMap) => ((path: JsonPath, closest?: boolean) => ILocation | undefined);

package/dist/parsers/json-locator.js

@@ -0,0 +1,151 @@
+import { createLineMap } from "./lines.js";
+const ARRAY_INDEX = /^(?:0|[1-9]\d*)$/;
+const QUOTE = 34;
+const BACKSLASH = 92;
+const OPEN_BRACE = 123;
+const CLOSE_BRACE = 125;
+const OPEN_BRACKET = 91;
+const CLOSE_BRACKET = 93;
+const COMMA = 44;
+const isWhitespace = (code) => code === 32 || code === 10 || code === 13 || code === 9;
+const stringEnd = (source, start) => {
+  let quote = source.indexOf('"', start + 1);
+  while (quote !== -1) {
+    let slashes = 0;
+    for (let i = quote - 1; source.charCodeAt(i) === BACKSLASH; i--)
+      slashes++;
+    if ((slashes & 1) === 0)
+      return quote + 1;
+    quote = source.indexOf('"', quote + 1);
+  }
+  return -1;
+};
+const decodeKey = (literal) => {
+  const raw = literal.slice(1, -1);
+  if (!raw.includes("\\"))
+    return raw;
+  try {
+    return JSON.parse(literal);
+  } catch {
+    return raw;
+  }
+};
+const createJsonLocator = (source, lineMap) => {
+  const length = source.length;
+  const containers = /* @__PURE__ */ new Map();
+  let lines = lineMap;
+  const skipWhitespace = (offset) => {
+    let i = offset;
+    while (i < length && isWhitespace(source.charCodeAt(i)))
+      i++;
+    return i;
+  };
+  const valueEnd = (start) => {
+    const first = source.charCodeAt(start);
+    if (first === QUOTE)
+      return stringEnd(source, start);
+    if (first === OPEN_BRACE || first === OPEN_BRACKET) {
+      let depth = 0;
+      for (let i2 = start; i2 < length; i2++) {
+        const code = source.charCodeAt(i2);
+        if (code === QUOTE) {
+          const close = stringEnd(source, i2);
+          if (close === -1)
+            return length;
+          i2 = close - 1;
+        } else if (code === OPEN_BRACE || code === OPEN_BRACKET)
+          depth++;
+        else if (code === CLOSE_BRACE || code === CLOSE_BRACKET) {
+          depth--;
+          if (depth === 0)
+            return i2 + 1;
+        }
+      }
+      return length;
+    }
+    let i = start;
+    while (i < length) {
+      const code = source.charCodeAt(i);
+      if (code === COMMA || code === CLOSE_BRACE || code === CLOSE_BRACKET || isWhitespace(code))
+        break;
+      i++;
+    }
+    return i;
+  };
+  const index = (start) => {
+    const cached = containers.get(start);
+    if (cached !== void 0)
+      return cached;
+    const isObject = source.charCodeAt(start) === OPEN_BRACE;
+    const close = isObject ? CLOSE_BRACE : CLOSE_BRACKET;
+    const members = /* @__PURE__ */ new Map();
+    const starts = [];
+    const ends = [];
+    let i = skipWhitespace(start + 1);
+    while (i < length && source.charCodeAt(i) !== close) {
+      if (isObject) {
+        const keyEnd = source.charCodeAt(i) === QUOTE ? stringEnd(source, i) : -1;
+        if (keyEnd === -1)
+          break;
+        const key = decodeKey(source.slice(i, keyEnd));
+        if (!members.has(key))
+          members.set(key, starts.length);
+        i = skipWhitespace(skipWhitespace(keyEnd) + 1);
+      }
+      const end = valueEnd(i);
+      if (end <= i)
+        break;
+      starts.push(i);
+      ends.push(end);
+      i = skipWhitespace(end);
+      if (source.charCodeAt(i) === COMMA)
+        i = skipWhitespace(i + 1);
+    }
+    const container = isObject ? { kind: "object", members, starts, ends } : { kind: "array", starts, ends };
+    containers.set(start, container);
+    return container;
+  };
+  const toLocation = (start, end) => {
+    if (lines === void 0)
+      lines = createLineMap(source);
+    return { range: { start: lines.positionAt(start), end: lines.positionAt(end) } };
+  };
+  let rootStart = -1;
+  let rootEnd = -1;
+  return (path, closest = false) => {
+    if (rootStart === -1) {
+      rootStart = skipWhitespace(0);
+      rootEnd = length;
+      while (rootEnd > rootStart && isWhitespace(source.charCodeAt(rootEnd - 1)))
+        rootEnd--;
+    }
+    if (rootStart >= length)
+      return void 0;
+    let start = rootStart;
+    let end = rootEnd;
+    for (const segment of path) {
+      const first = source.charCodeAt(start);
+      let member = -1;
+      if (first === OPEN_BRACE) {
+        const container2 = index(start);
+        member = container2.members.get(String(segment)) ?? -1;
+      } else if (first === OPEN_BRACKET) {
+        const text = String(segment);
+        if (ARRAY_INDEX.test(text)) {
+          const position = Number(text);
+          if (position < index(start).starts.length)
+            member = position;
+        }
+      }
+      if (member === -1)
+        return closest ? toLocation(start, end) : void 0;
+      const container = index(start);
+      start = container.starts[member];
+      end = container.ends[member];
+    }
+    return toLocation(start, end);
+  };
+};
+export {
+  createJsonLocator
+};

package/dist/parsers/json.d.ts

@@ -1,3 +1,10 @@
-import { type IParseResult } from './types.js';
+import { type Node } from 'jsonc-parser';
+import { type LineMap } from './lines.js';
+import { type ILocation, type IParseResult, type JsonPath } from './types.js';
 /** Parses strict JSON into data plus a source map, reporting JSON-specific syntax errors. */
 export declare const parseJson: <T = unknown>(source: string) => IParseResult<T>;
+/**
+ * Resolves paths against a `jsonc-parser` tree. When `closest` is set and the
+ * path leaves the document, the deepest node it reached is returned.
+ */
+export declare const createTreeLocator: (root: Node, lineMap: LineMap) => (path: JsonPath, closest?: boolean) => ILocation | undefined;

package/dist/parsers/json.js

@@ -1,12 +1,12 @@
 import { getNodeValue, parseTree, printParseErrorCode } from "jsonc-parser";
 import { findExcessiveNesting, MAX_NESTING_DEPTH } from "./depth.js";
+import { createJsonLocator } from "./json-locator.js";
 import { createLineMap } from "./lines.js";
 import { DiagnosticSeverity } from "./types.js";
 const parseJson = (source) => {
-  const lineMap = createLineMap(source);
   const excessive = findExcessiveNesting(source);
   if (excessive !== -1) {
-    const position = lineMap.positionAt(excessive);
+    const position = createLineMap(source).positionAt(excessive);
     return {
       data: void 0,
       diagnostics: [
@@ -19,6 +19,10 @@ const parseJson = (source) => {
       getLocationForJsonPath: () => void 0
     };
   }
+  const fast = parseValidJson(source);
+  if (fast !== void 0)
+    return fast;
+  const lineMap = createLineMap(source);
   const errors = [];
   const root = parseTree(source, errors, { allowTrailingComma: false, disallowComments: true });
   const data = root ? getNodeValue(root) : void 0;
@@ -30,27 +34,35 @@ const parseJson = (source) => {
       end: lineMap.positionAt(err.offset + err.length)
     }
   }));
-  const getLocationForJsonPath = (path, closest = false) => {
-    if (!root)
-      return void 0;
-    const p = path.slice();
-    while (true) {
-      const node = findNode(root, p);
-      if (node) {
-        return {
-          range: {
-            start: lineMap.positionAt(node.offset),
-            end: lineMap.positionAt(node.offset + node.length)
-          }
-        };
-      }
-      if (!closest || p.length === 0)
-        return void 0;
-      p.pop();
-    }
-  };
+  const getLocationForJsonPath = root ? createTreeLocator(root, lineMap) : () => void 0;
   return { data, diagnostics, getLocationForJsonPath };
 };
+const parseValidJson = (source) => {
+  let data;
+  try {
+    data = JSON.parse(source);
+  } catch {
+    return void 0;
+  }
+  return { data, diagnostics: [], getLocationForJsonPath: createJsonLocator(source) };
+};
+const createTreeLocator = (root, lineMap) => (path, closest = false) => {
+  const p = path.slice();
+  while (true) {
+    const node = findNode(root, p);
+    if (node) {
+      return {
+        range: {
+          start: lineMap.positionAt(node.offset),
+          end: lineMap.positionAt(node.offset + node.length)
+        }
+      };
+    }
+    if (!closest || p.length === 0)
+      return void 0;
+    p.pop();
+  }
+};
 const ARRAY_INDEX = /^(?:0|[1-9]\d*)$/;
 const findNode = (root, path) => {
   let node = root;
@@ -71,5 +83,6 @@ const findNode = (root, path) => {
   return node;
 };
 export {
+  createTreeLocator,
   parseJson
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/lint",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "A fast, format-agnostic JSON/YAML style-guide linter with JSON Schema and custom rules.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -46,6 +46,7 @@
     "test": "NODE_ENV=production vitest run --root ../.. packages/lint/",
     "prebench": "bun run build && bun run --filter='@amritk/runtime-validators' --filter='@amritk/yaml' --filter='@amritk/resolve-refs' build",
     "bench": "bun run ./bench/run.ts",
+    "bench:large": "bun --conditions development ./bench/large.ts",
     "prebench:node": "bun run build && bun run --filter='@amritk/runtime-validators' --filter='@amritk/yaml' --filter='@amritk/resolve-refs' build",
     "bench:node": "node ./bench/run.ts"
   },