@amritk/lint 0.3.2 → 0.4.0

package/dist/core/lint.js

@@ -1,91 +1,84 @@
-import { detectFormat } from '../parsers/index.js';
-import { createDocument } from './document.js';
-import { runPlugins } from './plugin.js';
-import { createLinter } from './runner.js';
-import { DiagnosticSeverity } from './types.js';
+import { detectFormat } from "../parsers/index.js";
+import { createDocument } from "./document.js";
+import { runPlugins } from "./plugin.js";
+import { createLinter } from "./runner.js";
+import { DiagnosticSeverity } from "./types.js";
 const toParserSeverity = (value) => {
-    if (value === undefined)
-        return undefined;
-    if (typeof value === 'number')
-        return value;
-    if (value === 'off')
-        return 'off';
-    const names = {
-        error: DiagnosticSeverity.Error,
-        warn: DiagnosticSeverity.Warning,
-        info: DiagnosticSeverity.Information,
-        hint: DiagnosticSeverity.Hint,
-    };
-    return names[value];
+  if (value === void 0)
+    return void 0;
+  if (typeof value === "number")
+    return value;
+  if (value === "off")
+    return "off";
+  const names = {
+    error: DiagnosticSeverity.Error,
+    warn: DiagnosticSeverity.Warning,
+    info: DiagnosticSeverity.Information,
+    hint: DiagnosticSeverity.Hint
+  };
+  return names[value];
 };
 const byPosition = (a, b) => {
-    const sa = a.source ?? '';
-    const sb = b.source ?? '';
-    if (sa !== sb)
-        return sa < sb ? -1 : 1;
-    return a.range.start.line - b.range.start.line || a.range.start.character - b.range.start.character;
+  const sa = a.source ?? "";
+  const sb = b.source ?? "";
+  if (sa !== sb)
+    return sa < sb ? -1 : 1;
+  return a.range.start.line - b.range.start.line || a.range.start.character - b.range.start.character;
 };
-/**
- * Lints `input` against a normalized `ruleset`, returning the full
- * {@link LintResult} (findings plus anything the configured `plugins` produced).
- * This is the format-agnostic pipeline — parse with source maps → resolve (via
- * the injected {@link LintResolver}) → run the ruleset → run plugins. A higher
- * level entry point (such as `@amritk/lint`) supplies the ruleset, and
- * optionally a resolver and format-skip predicate; {@link lint} is a thin
- * wrapper returning just the diagnostics.
- */
-export const lintWithResult = async (input, options) => {
-    const { ruleset, resolve, skip, plugins, ...documentOptions } = options;
-    const duplicateKeys = toParserSeverity(ruleset.parserOptions?.duplicateKeys);
-    const incompatibleValues = toParserSeverity(ruleset.parserOptions?.incompatibleValues);
-    const document = createDocument(input, {
-        ...documentOptions,
-        ...(duplicateKeys !== undefined ? { duplicateKeys } : {}),
-        ...(incompatibleValues !== undefined ? { incompatibleValues } : {}),
-    });
-    // Skip unrecognized-format documents before paying for resolution or the run.
-    if (skip?.(document.data))
-        return { diagnostics: [], pluginData: {} };
-    let resolved = document.data;
-    let sources;
-    let resolverDiagnostics = [];
-    if (resolve) {
-        const result = await resolve(document, { input });
-        resolved = result.resolved;
-        sources = result.sources;
-        if (result.diagnostics)
-            resolverDiagnostics = result.diagnostics;
-    }
-    const ruleResults = await createLinter(ruleset).run(document, { resolved, ...(sources ? { sources } : {}) });
-    const parserResults = document.diagnostics.map((diagnostic) => {
-        const result = {
-            code: 'parser',
-            message: diagnostic.message,
-            path: diagnostic.path ?? [],
-            severity: diagnostic.severity,
-            range: diagnostic.range,
-        };
-        if (document.source !== undefined)
-            result.source = document.source;
-        return result;
-    });
-    const diagnostics = [...parserResults, ...resolverDiagnostics, ...ruleResults].sort(byPosition);
-    if (!plugins || plugins.length === 0)
-        return { diagnostics, pluginData: {} };
-    const format = documentOptions.format ?? detectFormat(input);
-    const run = runPlugins(plugins, diagnostics, {
-        input,
-        format,
-        document,
-        resolved,
-        ruleset,
-        ...(documentOptions.source !== undefined ? { source: documentOptions.source } : {}),
-    });
-    return {
-        diagnostics: run.diagnostics,
-        pluginData: run.data,
-        ...(run.output !== undefined ? { output: run.output } : {}),
+const lintWithResult = async (input, options) => {
+  const { ruleset, resolve, skip, plugins, ...documentOptions } = options;
+  const duplicateKeys = toParserSeverity(ruleset.parserOptions?.duplicateKeys);
+  const incompatibleValues = toParserSeverity(ruleset.parserOptions?.incompatibleValues);
+  const document = createDocument(input, {
+    ...documentOptions,
+    ...duplicateKeys !== void 0 ? { duplicateKeys } : {},
+    ...incompatibleValues !== void 0 ? { incompatibleValues } : {}
+  });
+  if (skip?.(document.data))
+    return { diagnostics: [], pluginData: {} };
+  let resolved = document.data;
+  let sources;
+  let resolverDiagnostics = [];
+  if (resolve) {
+    const result = await resolve(document, { input });
+    resolved = result.resolved;
+    sources = result.sources;
+    if (result.diagnostics)
+      resolverDiagnostics = result.diagnostics;
+  }
+  const ruleResults = await createLinter(ruleset).run(document, { resolved, ...sources ? { sources } : {} });
+  const parserResults = document.diagnostics.map((diagnostic) => {
+    const result = {
+      code: "parser",
+      message: diagnostic.message,
+      path: diagnostic.path ?? [],
+      severity: diagnostic.severity,
+      range: diagnostic.range
     };
+    if (document.source !== void 0)
+      result.source = document.source;
+    return result;
+  });
+  const diagnostics = [...parserResults, ...resolverDiagnostics, ...ruleResults].sort(byPosition);
+  if (!plugins || plugins.length === 0)
+    return { diagnostics, pluginData: {} };
+  const format = documentOptions.format ?? detectFormat(input);
+  const run = runPlugins(plugins, diagnostics, {
+    input,
+    format,
+    document,
+    resolved,
+    ruleset,
+    ...documentOptions.source !== void 0 ? { source: documentOptions.source } : {}
+  });
+  return {
+    diagnostics: run.diagnostics,
+    pluginData: run.data,
+    ...run.output !== void 0 ? { output: run.output } : {}
+  };
+};
+const lint = async (input, options) => (await lintWithResult(input, options)).diagnostics;
+export {
+  lint,
+  lintWithResult
 };
-/** Lints `input` against a normalized `ruleset` and returns just the findings. */
-export const lint = async (input, options) => (await lintWithResult(input, options)).diagnostics;

package/dist/core/plugin.js

@@ -1,31 +1,23 @@
-/**
- * Runs `plugins` in order over `diagnostics`. Each plugin sees the (possibly
- * already transformed) diagnostics from the previous one; when a plugin returns
- * `output`, later plugins and the context see that rewritten text as `input`.
- *
- * Note: only `input` (and the diagnostics) are refreshed between plugins. The
- * `document` and `resolved` tree in the context are the *originally* parsed ones,
- * so after a plugin rewrites `output` those become stale relative to the new
- * text. A plugin that must operate on the up-to-date parsed tree should re-parse
- * `context.input` itself rather than trust `document`/`resolved`.
- */
-export const runPlugins = (plugins, diagnostics, context) => {
-    let currentDiagnostics = diagnostics;
-    let currentInput = context.input;
-    let output;
-    const data = {};
-    for (const plugin of plugins) {
-        const result = plugin.afterLint?.(currentDiagnostics, { ...context, input: currentInput });
-        if (!result)
-            continue;
-        if (result.diagnostics)
-            currentDiagnostics = result.diagnostics;
-        if (result.output !== undefined) {
-            output = result.output;
-            currentInput = result.output;
-        }
-        if (result.data !== undefined)
-            data[plugin.name] = result.data;
+const runPlugins = (plugins, diagnostics, context) => {
+  let currentDiagnostics = diagnostics;
+  let currentInput = context.input;
+  let output;
+  const data = {};
+  for (const plugin of plugins) {
+    const result = plugin.afterLint?.(currentDiagnostics, { ...context, input: currentInput });
+    if (!result)
+      continue;
+    if (result.diagnostics)
+      currentDiagnostics = result.diagnostics;
+    if (result.output !== void 0) {
+      output = result.output;
+      currentInput = result.output;
     }
-    return { diagnostics: currentDiagnostics, data, ...(output !== undefined ? { output } : {}) };
+    if (result.data !== void 0)
+      data[plugin.name] = result.data;
+  }
+  return { diagnostics: currentDiagnostics, data, ...output !== void 0 ? { output } : {} };
+};
+export {
+  runPlugins
 };

package/dist/core/pointers.js

@@ -1,169 +1,125 @@
-import { dirname, resolve as resolvePath } from 'node:path';
-const isContainer = (value) => typeof value === 'object' && value !== null;
-/**
- * Decodes one JSON-pointer segment the way `getByPointer` does: percent-escapes
- * first (pointers arrive inside URI-reference `$ref`s), then the JSON-pointer
- * escapes `~1`/`~0`, then all-digit segments become numbers. Shared by both the
- * `#/...` and fragment parsers so they decode identically.
- */
+import { dirname, resolve as resolvePath } from "node:path";
+const isContainer = (value) => typeof value === "object" && value !== null;
 const decodeSegment = (segment) => {
-    let decoded = segment;
-    try {
-        decoded = decodeURIComponent(segment);
-    }
-    catch {
-        // Leave invalid percent-escapes as-is rather than throwing.
-    }
-    decoded = decoded.replace(/~1/g, '/').replace(/~0/g, '~');
-    return /^\d+$/.test(decoded) ? Number(decoded) : decoded;
+  let decoded = segment;
+  try {
+    decoded = decodeURIComponent(segment);
+  } catch {
+  }
+  decoded = decoded.replace(/~1/g, "/").replace(/~0/g, "~");
+  return /^\d+$/.test(decoded) ? Number(decoded) : decoded;
 };
-/** Parses an internal JSON pointer (`#/a/b`) into a path; returns undefined for external refs. */
-export const pointerToPath = (pointer) => {
-    if (pointer === '#')
-        return [];
-    if (!pointer.startsWith('#/'))
-        return undefined;
-    return pointer.slice(2).split('/').map(decodeSegment);
+const pointerToPath = (pointer) => {
+  if (pointer === "#")
+    return [];
+  if (!pointer.startsWith("#/"))
+    return void 0;
+  return pointer.slice(2).split("/").map(decodeSegment);
 };
 const isRemote = (location) => /^https?:\/\//i.test(location);
-/**
- * Resolves the location of `ref` (its file/URL part) relative to `base`, exactly
- * as `@amritk/resolve-refs` does, so the keys we look up in the source set match
- * the documents the resolver loaded.
- */
 const joinLocation = (base, ref) => {
-    if (isRemote(ref))
-        return ref;
-    if (isRemote(base))
-        return new URL(ref, base).href;
-    return resolvePath(dirname(base), ref);
+  if (isRemote(ref))
+    return ref;
+  if (isRemote(base))
+    return new URL(ref, base).href;
+  return resolvePath(dirname(base), ref);
 };
-/** Splits a `$ref` into its document part and JSON-pointer fragment (without `#`). */
 const splitRef = (ref) => {
-    const hashIndex = ref.indexOf('#');
-    return {
-        filePart: hashIndex === -1 ? ref : ref.slice(0, hashIndex),
-        fragment: hashIndex === -1 ? '' : ref.slice(hashIndex + 1),
-    };
+  const hashIndex = ref.indexOf("#");
+  return {
+    filePart: hashIndex === -1 ? ref : ref.slice(0, hashIndex),
+    fragment: hashIndex === -1 ? "" : ref.slice(hashIndex + 1)
+  };
 };
-/**
- * Parses a JSON-pointer fragment (the part after `#`, e.g. `/a/b`) into a path,
- * mirroring `getByPointer`'s decoding (`%XX` then `~1`/`~0`) so cross-file
- * pointers resolve to the same nodes the resolver inlined.
- */
 const fragmentToPath = (fragment) => {
-    if (fragment === '' || fragment === '/')
-        return [];
-    return fragment.replace(/^\//, '').split('/').map(decodeSegment);
+  if (fragment === "" || fragment === "/")
+    return [];
+  return fragment.replace(/^\//, "").split("/").map(decodeSegment);
 };
 const getAtPath = (root, path) => {
-    let node = root;
-    for (const segment of path) {
-        if (!isContainer(node))
-            return undefined;
-        node = node[segment];
-    }
-    return node;
+  let node = root;
+  for (const segment of path) {
+    if (!isContainer(node))
+      return void 0;
+    node = node[segment];
+  }
+  return node;
 };
-/**
- * Translates a path into the *resolved* (dereferenced) document back into the
- * equivalent path in the *original* source document, following internal `$ref`s.
- * This lets findings produced against the resolved tree resolve to the exact
- * line:column of the original `$ref` target. External refs stop the walk at the
- * `$ref` site.
- */
-export const resolveSourcePath = (root, path) => {
-    let originalPath = [];
-    let node = root;
-    const followRefs = () => {
-        let guard = 0;
-        while (isContainer(node) && !Array.isArray(node) && typeof node['$ref'] === 'string' && guard++ < 100) {
-            const target = pointerToPath(node['$ref']);
-            if (!target)
-                return;
-            originalPath = [...target];
-            node = getAtPath(root, target);
-        }
-    };
-    followRefs();
-    for (const segment of path) {
-        if (!isContainer(node))
-            break;
-        originalPath.push(segment);
-        node = node[segment];
-        followRefs();
+const resolveSourcePath = (root, path) => {
+  let originalPath = [];
+  let node = root;
+  const followRefs = () => {
+    let guard = 0;
+    while (isContainer(node) && !Array.isArray(node) && typeof node["$ref"] === "string" && guard++ < 100) {
+      const target = pointerToPath(node["$ref"]);
+      if (!target)
+        return;
+      originalPath = [...target];
+      node = getAtPath(root, target);
     }
-    return originalPath;
-};
-/**
- * Cross-document generalization of {@link resolveSourcePath}: translates a path
- * in the *resolved* (dereferenced) tree back to the document it actually came
- * from and the path within it, following both internal (`#/...`) and external
- * (other-file / remote) `$ref`s through the {@link IDocumentRegistry}. This is
- * what lets a finding on a node inlined from `./pet.yaml` report `pet.yaml`'s own
- * line:column instead of the `$ref` site in the root.
- *
- * The walk re-derives the resolver's traversal over the *unresolved* documents,
- * so a `$ref` whose target file is not in the registry (e.g. it failed to load)
- * stops the walk at the last known location rather than guessing. Prefer
- * {@link resolveSourceOriginFromMap} when the resolver supplies an origin map —
- * it avoids re-deriving this traversal.
- */
-export const resolveSourceOrigin = (registry, path) => {
-    let location = registry.rootLocation;
-    let root = registry.get(location)?.data;
-    let originalPath = [];
-    let node = root;
-    const followRefs = () => {
-        let guard = 0;
-        while (isContainer(node) && !Array.isArray(node) && typeof node['$ref'] === 'string' && guard++ < 1000) {
-            const { filePart, fragment } = splitRef(node['$ref']);
-            if (filePart !== '') {
-                const target = joinLocation(location, filePart);
-                const doc = registry.get(target);
-                if (!doc)
-                    return;
-                location = target;
-                root = doc.data;
-            }
-            originalPath = fragmentToPath(fragment);
-            node = getAtPath(root, originalPath);
-        }
-    };
+  };
+  followRefs();
+  for (const segment of path) {
+    if (!isContainer(node))
+      break;
+    originalPath.push(segment);
+    node = node[segment];
     followRefs();
-    for (const segment of path) {
-        if (!isContainer(node))
-            break;
-        originalPath.push(segment);
-        node = node[segment];
-        followRefs();
+  }
+  return originalPath;
+};
+const resolveSourceOrigin = (registry, path) => {
+  let location = registry.rootLocation;
+  let root = registry.get(location)?.data;
+  let originalPath = [];
+  let node = root;
+  const followRefs = () => {
+    let guard = 0;
+    while (isContainer(node) && !Array.isArray(node) && typeof node["$ref"] === "string" && guard++ < 1e3) {
+      const { filePart, fragment } = splitRef(node["$ref"]);
+      if (filePart !== "") {
+        const target = joinLocation(location, filePart);
+        const doc = registry.get(target);
+        if (!doc)
+          return;
+        location = target;
+        root = doc.data;
+      }
+      originalPath = fragmentToPath(fragment);
+      node = getAtPath(root, originalPath);
     }
-    return { location, path: originalPath };
+  };
+  followRefs();
+  for (const segment of path) {
+    if (!isContainer(node))
+      break;
+    originalPath.push(segment);
+    node = node[segment];
+    followRefs();
+  }
+  return { location, path: originalPath };
 };
-/**
- * Single-walk equivalent of {@link resolveSourceOrigin} that uses the resolver's
- * per-node origin map instead of re-walking the unresolved documents. We descend
- * the *resolved* tree along `path`; whenever we step onto a node the resolver
- * stamped (it was inlined from a `$ref`), we re-base onto that node's origin
- * document and in-file path, then keep appending the remaining segments. Nodes
- * straight from the root carry no stamp, so they stay attributed to the root.
- */
-export const resolveSourceOriginFromMap = (resolved, origins, rootLocation, path) => {
-    let location = rootLocation;
-    let inFilePath = [];
-    let node = resolved;
-    for (const segment of path) {
-        if (!isContainer(node))
-            break;
-        node = node[segment];
-        const stamp = isContainer(node) ? origins.get(node) : undefined;
-        if (stamp) {
-            location = stamp.location;
-            inFilePath = [...stamp.pointer];
-        }
-        else {
-            inFilePath.push(segment);
-        }
+const resolveSourceOriginFromMap = (resolved, origins, rootLocation, path) => {
+  let location = rootLocation;
+  let inFilePath = [];
+  let node = resolved;
+  for (const segment of path) {
+    if (!isContainer(node))
+      break;
+    node = node[segment];
+    const stamp = isContainer(node) ? origins.get(node) : void 0;
+    if (stamp) {
+      location = stamp.location;
+      inFilePath = [...stamp.pointer];
+    } else {
+      inFilePath.push(segment);
     }
-    return { location, path: inFilePath };
+  }
+  return { location, path: inFilePath };
+};
+export {
+  pointerToPath,
+  resolveSourceOrigin,
+  resolveSourceOriginFromMap,
+  resolveSourcePath
 };