@amritk/lint 0.3.2 → 0.4.0

package/dist/parsers/index.d.ts

@@ -1,7 +1,7 @@
 export { type ApplyEditOpsResult, applyEditOps, applyEditOpsWithChanges, type EditOp } from './edit-model.js';
 export { parseJson } from './json.js';
 export { createLineMap, type LineMap } from './lines.js';
-export * from './types.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';
 import type { IParseResult, IParserOptions } from './types.js';
 /** Which concrete parser a document is routed to. */

package/dist/parsers/index.js

@@ -1,21 +1,25 @@
-export { applyEditOps, applyEditOpsWithChanges } from './edit-model.js';
-export { parseJson } from './json.js';
-export { createLineMap } from './lines.js';
-export * from './types.js';
-export { parseYaml } from './yaml.js';
-import { parseJson } from './json.js';
-import { parseYaml } from './yaml.js';
-/** Guesses the format from the first non-whitespace character (`{`/`[` ⇒ JSON, else YAML). */
-export const detectFormat = (source) => {
-    const trimmed = source.trimStart();
-    return trimmed.startsWith('{') || trimmed.startsWith('[') ? 'json' : 'yaml';
+import { applyEditOps, applyEditOpsWithChanges } from "./edit-model.js";
+import { parseJson } from "./json.js";
+import { createLineMap } from "./lines.js";
+import { DiagnosticSeverity } from "./types.js";
+import { parseYaml } from "./yaml.js";
+import { parseJson as parseJson2 } from "./json.js";
+import { parseYaml as parseYaml2 } from "./yaml.js";
+const detectFormat = (source) => {
+  const trimmed = source.trimStart();
+  return trimmed.startsWith("{") || trimmed.startsWith("[") ? "json" : "yaml";
 };
-/**
- * Parses a document with source maps. YAML is a JSON superset, so the YAML
- * parser is the default and handles both; the JSON parser is used when a strict
- * JSON document is detected or requested (it reports JSON-specific errors).
- */
-export const parseWithPointers = (source, options = {}) => {
-    const format = options.format ?? detectFormat(source);
-    return format === 'json' ? parseJson(source) : parseYaml(source, options);
+const parseWithPointers = (source, options = {}) => {
+  const format = options.format ?? detectFormat(source);
+  return format === "json" ? parseJson2(source) : parseYaml2(source, options);
+};
+export {
+  DiagnosticSeverity,
+  applyEditOps,
+  applyEditOpsWithChanges,
+  createLineMap,
+  detectFormat,
+  parseJson,
+  parseWithPointers,
+  parseYaml
 };

package/dist/parsers/json.js

@@ -1,38 +1,40 @@
-import { findNodeAtLocation, getNodeValue, parseTree, printParseErrorCode } from 'jsonc-parser';
-import { createLineMap } from './lines.js';
-import { DiagnosticSeverity } from './types.js';
-/** Parses strict JSON into data plus a source map, reporting JSON-specific syntax errors. */
-export const parseJson = (source) => {
-    const lineMap = createLineMap(source);
-    const errors = [];
-    const root = parseTree(source, errors, { allowTrailingComma: false, disallowComments: true });
-    const data = (root ? getNodeValue(root) : undefined);
-    const diagnostics = errors.map((err) => ({
-        message: printParseErrorCode(err.error),
-        severity: DiagnosticSeverity.Error,
-        range: {
-            start: lineMap.positionAt(err.offset),
-            end: lineMap.positionAt(err.offset + err.length),
-        },
-    }));
-    const getLocationForJsonPath = (path, closest = false) => {
-        if (!root)
-            return undefined;
-        const p = path.slice();
-        while (true) {
-            const node = findNodeAtLocation(root, p);
-            if (node) {
-                return {
-                    range: {
-                        start: lineMap.positionAt(node.offset),
-                        end: lineMap.positionAt(node.offset + node.length),
-                    },
-                };
-            }
-            if (!closest || p.length === 0)
-                return undefined;
-            p.pop();
-        }
-    };
-    return { data, diagnostics, getLocationForJsonPath };
+import { findNodeAtLocation, getNodeValue, parseTree, printParseErrorCode } from "jsonc-parser";
+import { createLineMap } from "./lines.js";
+import { DiagnosticSeverity } from "./types.js";
+const parseJson = (source) => {
+  const lineMap = createLineMap(source);
+  const errors = [];
+  const root = parseTree(source, errors, { allowTrailingComma: false, disallowComments: true });
+  const data = root ? getNodeValue(root) : void 0;
+  const diagnostics = errors.map((err) => ({
+    message: printParseErrorCode(err.error),
+    severity: DiagnosticSeverity.Error,
+    range: {
+      start: lineMap.positionAt(err.offset),
+      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 = findNodeAtLocation(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();
+    }
+  };
+  return { data, diagnostics, getLocationForJsonPath };
+};
+export {
+  parseJson
 };

package/dist/parsers/lines.js

@@ -1,28 +1,25 @@
-/**
- * Builds a {@link LineMap} for `source`. The line-start offsets are precomputed
- * once so each `positionAt` lookup is a binary search rather than a re-scan.
- */
-export const createLineMap = (source) => {
-    const length = source.length;
-    // Offset at which each line starts. lineStarts[0] === 0.
-    const lineStarts = [0];
-    for (let i = 0; i < source.length; i++) {
-        if (source.charCodeAt(i) === 10 /* \n */)
-            lineStarts.push(i + 1);
+const createLineMap = (source) => {
+  const length = source.length;
+  const lineStarts = [0];
+  for (let i = 0; i < source.length; i++) {
+    if (source.charCodeAt(i) === 10)
+      lineStarts.push(i + 1);
+  }
+  const positionAt = (offset) => {
+    const clamped = Math.max(0, Math.min(offset, length));
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while (low < high) {
+      const mid = low + high + 1 >> 1;
+      if ((lineStarts[mid] ?? 0) <= clamped)
+        low = mid;
+      else
+        high = mid - 1;
     }
-    const positionAt = (offset) => {
-        const clamped = Math.max(0, Math.min(offset, length));
-        // Binary search for the last line start <= clamped.
-        let low = 0;
-        let high = lineStarts.length - 1;
-        while (low < high) {
-            const mid = (low + high + 1) >> 1;
-            if ((lineStarts[mid] ?? 0) <= clamped)
-                low = mid;
-            else
-                high = mid - 1;
-        }
-        return { line: low, character: clamped - (lineStarts[low] ?? 0) };
-    };
-    return { positionAt };
+    return { line: low, character: clamped - (lineStarts[low] ?? 0) };
+  };
+  return { positionAt };
+};
+export {
+  createLineMap
 };

package/dist/parsers/types.js

@@ -1,8 +1,10 @@
-/** Severity levels, ordered most-to-least severe to match LSP's numeric scale. */
-export var DiagnosticSeverity;
-(function (DiagnosticSeverity) {
-    DiagnosticSeverity[DiagnosticSeverity["Error"] = 0] = "Error";
-    DiagnosticSeverity[DiagnosticSeverity["Warning"] = 1] = "Warning";
-    DiagnosticSeverity[DiagnosticSeverity["Information"] = 2] = "Information";
-    DiagnosticSeverity[DiagnosticSeverity["Hint"] = 3] = "Hint";
+var DiagnosticSeverity;
+(function(DiagnosticSeverity2) {
+  DiagnosticSeverity2[DiagnosticSeverity2["Error"] = 0] = "Error";
+  DiagnosticSeverity2[DiagnosticSeverity2["Warning"] = 1] = "Warning";
+  DiagnosticSeverity2[DiagnosticSeverity2["Information"] = 2] = "Information";
+  DiagnosticSeverity2[DiagnosticSeverity2["Hint"] = 3] = "Hint";
 })(DiagnosticSeverity || (DiagnosticSeverity = {}));
+export {
+  DiagnosticSeverity
+};

package/dist/parsers/yaml.js

@@ -1,213 +1,146 @@
-import { isAlias, isMap, isPair, isScalar, isSeq, parseAllDocuments, } from '@amritk/yaml';
-import { createLineMap } from './lines.js';
-import { DiagnosticSeverity, } from './types.js';
-/**
- * Encodes a path into a lookup key. Each segment is tagged by kind (`.` for a
- * key, `[]` for an index) so distinct paths cannot collide: a plain `join` turns
- * a `null` map key into `''` (colliding with the root path `[]`) and cannot tell
- * the numeric index `0` from the string key `"0"`. The tags keep them apart.
- */
-const pathKey = (path) => path.map((segment) => (typeof segment === 'number' ? `[${segment}]` : `.${segment}`)).join('');
-/**
- * Canonically serializes a complex (map/seq) mapping key into a stable, distinct
- * segment. `toJS`'s `keyText` collapses every complex key to `''`, so two
- * distinct complex keys (and their whole value subtrees) would share one index
- * slot and clobber each other. A structural serialization keeps them apart:
- * `[a,b]` for a sequence key, `{k:v}` for a mapping key, recursively. Strings are
- * quoted so a scalar member can't be confused with structure, and aliases render
- * as `*name` (never expanded, so this stays bounded regardless of the anchor).
- */
+import { isAlias, isMap, isPair, isScalar, isSeq, parseAllDocuments } from "@amritk/yaml";
+import { createLineMap } from "./lines.js";
+import { DiagnosticSeverity } from "./types.js";
+const pathKey = (path) => path.map((segment) => typeof segment === "number" ? `[${segment}]` : `.${segment}`).join("");
 const serializeComplexKey = (node) => {
-    if (isSeq(node))
-        return `[${node.items.map(serializeComplexKey).join(',')}]`;
-    if (isMap(node)) {
-        return `{${node.items
-            .filter(isPair)
-            .map((pair) => `${serializeComplexKey(pair.key)}:${pair.value ? serializeComplexKey(pair.value) : 'null'}`)
-            .join(',')}}`;
-    }
-    if (isAlias(node))
-        return `*${node.source}`;
-    const v = node.value;
-    return typeof v === 'string' ? JSON.stringify(v) : v === null ? 'null' : String(v);
+  if (isSeq(node))
+    return `[${node.items.map(serializeComplexKey).join(",")}]`;
+  if (isMap(node)) {
+    return `{${node.items.filter(isPair).map((pair) => `${serializeComplexKey(pair.key)}:${pair.value ? serializeComplexKey(pair.value) : "null"}`).join(",")}}`;
+  }
+  if (isAlias(node))
+    return `*${node.source}`;
+  const v = node.value;
+  return typeof v === "string" ? JSON.stringify(v) : v === null ? "null" : String(v);
 };
-/**
- * Stringifies a mapping key into an index segment. Scalar, null, and alias keys
- * match `toJS`'s `keyText` (`null`, the `String()` form, `*name`) so scalar-keyed
- * paths line up with the projected data. Complex (map/seq) keys — which `toJS`
- * cannot address individually — get a canonical structural serialization instead
- * of collapsing to `''`, so distinct complex keys occupy distinct index slots.
- */
 const keyToString = (key) => {
-    if (isScalar(key)) {
-        const v = key.value;
-        return typeof v === 'string' ? v : v === null ? 'null' : String(v);
-    }
-    if (isAlias(key))
-        return `*${key.source}`;
-    return serializeComplexKey(key);
+  if (isScalar(key)) {
+    const v = key.value;
+    return typeof v === "string" ? v : v === null ? "null" : String(v);
+  }
+  if (isAlias(key))
+    return `*${key.source}`;
+  return serializeComplexKey(key);
 };
-/**
- * Parses YAML (a JSON superset, so this handles both) into data plus a source
- * map, surfacing duplicate-key and incompatible-value diagnostics per `options`.
- *
- * A `---`-separated stream is parsed as multiple documents (via
- * `parseAllDocuments`), each linted independently: `data` becomes an array of
- * per-document values and every position key / finding path is prefixed with the
- * zero-based document index, so a violation in a later document resolves to its
- * own range instead of being silently dropped. A single-document source keeps the
- * flat shape — `data` is the document value and paths are unprefixed — so existing
- * callers and rulesets are unaffected. Node ranges are absolute offsets into the
- * shared source, so diagnostics and positions in later documents are already
- * correct without any per-document offset arithmetic.
- */
-export const parseYaml = (source, options = {}) => {
-    const lineMap = createLineMap(source);
-    const duplicateKeys = options.duplicateKeys;
-    const dedupe = duplicateKeys === 'off' || duplicateKeys === false;
-    // A configured severity (Warning/Information/Hint) still detects duplicates; we
-    // just re-map the reported severity below. Only `off`/`false` turns detection off.
-    const dupSeverity = typeof duplicateKeys === 'number' ? duplicateKeys : DiagnosticSeverity.Error;
-    // Incompatible-value detection is opt-in: it runs only when a severity is
-    // configured. `undefined`/`off`/`false` leaves it disabled.
-    const incompatibleValues = options.incompatibleValues;
-    const incompatSeverity = typeof incompatibleValues === 'number' ? incompatibleValues : undefined;
-    const docs = parseAllDocuments(source, { uniqueKeys: !dedupe });
-    const index = new Map();
-    const diagnostics = [];
-    const pushError = (severity, message, start, end, code) => {
-        diagnostics.push({
-            ...(code !== undefined ? { code } : {}),
-            message,
-            severity,
-            range: { start: lineMap.positionAt(start), end: lineMap.positionAt(end) },
-        });
-    };
-    const rangeOf = (node) => ({
-        start: lineMap.positionAt(node.start),
-        end: lineMap.positionAt(node.end),
+const parseYaml = (source, options = {}) => {
+  const lineMap = createLineMap(source);
+  const duplicateKeys = options.duplicateKeys;
+  const dedupe = duplicateKeys === "off" || duplicateKeys === false;
+  const dupSeverity = typeof duplicateKeys === "number" ? duplicateKeys : DiagnosticSeverity.Error;
+  const incompatibleValues = options.incompatibleValues;
+  const incompatSeverity = typeof incompatibleValues === "number" ? incompatibleValues : void 0;
+  const docs = parseAllDocuments(source, { uniqueKeys: !dedupe });
+  const index = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  const pushError = (severity, message, start, end, code) => {
+    diagnostics.push({
+      ...code !== void 0 ? { code } : {},
+      message,
+      severity,
+      range: { start: lineMap.positionAt(start), end: lineMap.positionAt(end) }
     });
-    // Aliases are re-expanded into every path that reaches them, so nested aliases
-    // (the "billion laughs" shape) can fan out super-linearly. Bound the total
-    // nodes walked across the whole stream; on exhaustion we stop extending the
-    // index rather than throw — untouched paths simply fall back to the closest
-    // indexed ancestor.
-    let budget = Math.max(100_000, source.length * 100);
-    /** True when a pair is a `<<` merge key, whose value folds into the parent map. */
-    const isMergePair = (pair) => isScalar(pair.key) && pair.key.source === '<<';
-    /**
-     * Indexes the keys of a merged map (or list of maps, reached through the `<<`
-     * value) at the parent `path`. A merged key is skipped when the path is already
-     * occupied — by an explicit key or an earlier merge — mirroring `toJS`, where
-     * explicit keys and earlier merges win over later ones.
-     */
-    const walkMerge = (node, path) => {
-        const target = node != null && isAlias(node) ? node.target : node;
-        if (target == null)
-            return;
-        if (isSeq(target)) {
-            for (const item of target.items)
-                walkMerge(item, path);
-            return;
-        }
-        if (!isMap(target))
-            return;
-        for (const item of target.items) {
-            if (!isPair(item))
-                continue;
-            if (isMergePair(item)) {
-                walkMerge(item.value, path);
-                continue;
-            }
-            const childPath = [...path, keyToString(item.key)];
-            if (!index.has(pathKey(childPath)))
-                walk(item.value, childPath);
-        }
-    };
-    const walk = (node, path) => {
-        if (node == null || budget-- <= 0)
-            return;
-        index.set(pathKey(path), rangeOf(node));
-        if (isScalar(node)) {
-            // The core schema projects `.nan`/`.inf`/`-.inf` to non-finite JS numbers,
-            // which `JSON.stringify` silently rewrites to `null`. Report them when the
-            // caller opted in, so a value that won't survive a JSON round-trip is caught.
-            const value = node.value;
-            if (incompatSeverity !== undefined && typeof value === 'number' && !Number.isFinite(value)) {
-                pushError(incompatSeverity, `Value ${String(value)} cannot be represented in JSON and will serialize to null.`, node.start, node.end, 'INCOMPATIBLE_VALUE');
-            }
-            return;
-        }
-        // Follow an alias to its anchor definition so paths reachable only through the
-        // alias resolve to the anchored node (the alias itself keeps the range set
-        // above); an unresolved alias has no target and simply stops here.
-        const target = isAlias(node) ? node.target : node;
-        if (target == null)
-            return;
-        if (isMap(target)) {
-            const merges = [];
-            for (const item of target.items) {
-                if (!isPair(item))
-                    continue;
-                if (isMergePair(item)) {
-                    merges.push(item.value);
-                    continue;
-                }
-                walk(item.value, [...path, keyToString(item.key)]);
-            }
-            // Merged keys fill positions the explicit keys above did not claim.
-            for (const merge of merges)
-                walkMerge(merge, path);
-        }
-        else if (isSeq(target)) {
-            target.items.forEach((item, i) => {
-                walk(item, [...path, i]);
-            });
-        }
-    };
-    const collectProblems = (doc) => {
-        for (const err of doc.errors) {
-            // Duplicate keys honor the configured severity; every other parser error is
-            // a hard error.
-            const severity = err.code === 'DUPLICATE_KEY' ? dupSeverity : DiagnosticSeverity.Error;
-            pushError(severity, err.message, err.start, err.end);
-        }
-        for (const warn of doc.warnings) {
-            pushError(DiagnosticSeverity.Warning, warn.message, warn.start, warn.end);
-        }
-    };
-    let data;
-    if (docs.length > 1) {
-        // Multi-document stream: index each document under its own `[i, …]` prefix and
-        // project to an array of per-document values.
-        data = docs.map((doc, i) => {
-            walk(doc.contents, [i]);
-            collectProblems(doc);
-            return doc.toJS();
-        });
+  };
+  const rangeOf = (node) => ({
+    start: lineMap.positionAt(node.start),
+    end: lineMap.positionAt(node.end)
+  });
+  let budget = Math.max(1e5, source.length * 100);
+  const isMergePair = (pair) => isScalar(pair.key) && pair.key.source === "<<";
+  const walkMerge = (node, path) => {
+    const target = node != null && isAlias(node) ? node.target : node;
+    if (target == null)
+      return;
+    if (isSeq(target)) {
+      for (const item of target.items)
+        walkMerge(item, path);
+      return;
     }
-    else {
-        // Single document (or an empty stream): keep the flat, unprefixed shape.
-        const doc = docs[0];
-        if (doc) {
-            walk(doc.contents, []);
-            collectProblems(doc);
-            data = doc.toJS();
-        }
-        else {
-            data = null;
-        }
+    if (!isMap(target))
+      return;
+    for (const item of target.items) {
+      if (!isPair(item))
+        continue;
+      if (isMergePair(item)) {
+        walkMerge(item.value, path);
+        continue;
+      }
+      const childPath = [...path, keyToString(item.key)];
+      if (!index.has(pathKey(childPath)))
+        walk(item.value, childPath);
+    }
+  };
+  const walk = (node, path) => {
+    if (node == null || budget-- <= 0)
+      return;
+    index.set(pathKey(path), rangeOf(node));
+    if (isScalar(node)) {
+      const value = node.value;
+      if (incompatSeverity !== void 0 && typeof value === "number" && !Number.isFinite(value)) {
+        pushError(incompatSeverity, `Value ${String(value)} cannot be represented in JSON and will serialize to null.`, node.start, node.end, "INCOMPATIBLE_VALUE");
+      }
+      return;
     }
-    const getLocationForJsonPath = (path, closest = false) => {
-        const p = path.slice();
-        while (true) {
-            const range = index.get(pathKey(p));
-            if (range)
-                return { range };
-            if (!closest || p.length === 0)
-                return undefined;
-            p.pop();
+    const target = isAlias(node) ? node.target : node;
+    if (target == null)
+      return;
+    if (isMap(target)) {
+      const merges = [];
+      for (const item of target.items) {
+        if (!isPair(item))
+          continue;
+        if (isMergePair(item)) {
+          merges.push(item.value);
+          continue;
         }
-    };
-    return { data: data, diagnostics, getLocationForJsonPath };
+        walk(item.value, [...path, keyToString(item.key)]);
+      }
+      for (const merge of merges)
+        walkMerge(merge, path);
+    } else if (isSeq(target)) {
+      target.items.forEach((item, i) => {
+        walk(item, [...path, i]);
+      });
+    }
+  };
+  const collectProblems = (doc) => {
+    for (const err of doc.errors) {
+      const severity = err.code === "DUPLICATE_KEY" ? dupSeverity : DiagnosticSeverity.Error;
+      pushError(severity, err.message, err.start, err.end);
+    }
+    for (const warn of doc.warnings) {
+      pushError(DiagnosticSeverity.Warning, warn.message, warn.start, warn.end);
+    }
+  };
+  let data;
+  if (docs.length > 1) {
+    data = docs.map((doc, i) => {
+      walk(doc.contents, [i]);
+      collectProblems(doc);
+      return doc.toJS();
+    });
+  } else {
+    const doc = docs[0];
+    if (doc) {
+      walk(doc.contents, []);
+      collectProblems(doc);
+      data = doc.toJS();
+    } else {
+      data = null;
+    }
+  }
+  const getLocationForJsonPath = (path, closest = false) => {
+    const p = path.slice();
+    while (true) {
+      const range = index.get(pathKey(p));
+      if (range)
+        return { range };
+      if (!closest || p.length === 0)
+        return void 0;
+      p.pop();
+    }
+  };
+  return { data, diagnostics, getLocationForJsonPath };
+};
+export {
+  parseYaml
 };