@amritk/lint 0.3.2 → 0.4.0

package/dist/index.js

@@ -1,176 +1,161 @@
-import { readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { dirname, isAbsolute, resolve as resolvePath } from 'node:path';
-import { createRuleset as createCoreRuleset, lintWithResult, } from './core/index.js';
-import { createFixPlugin, FIX_PLUGIN_NAME } from './fix/index.js';
-import { builtinFunctions } from './functions/index.js';
-import { parseWithPointers } from './parsers/index.js';
-// Re-export the engine, built-in functions, and fix subsystem as the package's
-// public API. `export *` from `./core` also provides a low-level `createRuleset`,
-// but the higher-level wrapper defined below (which layers in the built-in
-// functions and file/package `extends` resolution) is the local export and wins.
-// Rendering findings is a consumer concern: `lintDocument` returns structured
-// `IDiagnostic[]`, and the caller decides how to display or serialize them.
-export * from './core/index.js';
-export * from './fix/index.js';
-export * from './functions/index.js';
-export { detectFormat, parseWithPointers } from './parsers/index.js';
-const require = createRequire(import.meta.url);
-/** Loads a ruleset definition from a file path by extension (YAML/JSON parsed, JS/CJS/MJS required). */
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, resolve as resolvePath } from "node:path";
+import { createRuleset as createCoreRuleset, lintWithResult } from "./core/index.js";
+import { createFixPlugin, FIX_PLUGIN_NAME } from "./fix/index.js";
+import { builtinFunctions } from "./functions/index.js";
+import { parseWithPointers } from "./parsers/index.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 { 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 as parseWithPointers2 } from "./parsers/index.js";
+const require2 = createRequire(import.meta.url);
 const loadRulesetFile = (file) => {
-    if (/\.(ya?ml|json)$/i.test(file)) {
-        return parseWithPointers(readFileSync(file, 'utf8')).data;
-    }
-    const module = require(file);
-    return (module.default ?? module);
+  if (/\.(ya?ml|json)$/i.test(file)) {
+    return parseWithPointers(readFileSync(file, "utf8")).data;
+  }
+  const module = require2(file);
+  return module.default ?? module;
 };
-/**
- * Resolves an `extends` reference to a ruleset definition. Supports:
- * - local file paths (relative to `basePath`, or absolute): `.yaml` / `.yml` / `.json` / `.js`,
- * - npm package specifiers (resolved from `basePath`), including subpaths.
- *
- * The engine ships no named built-in rulesets, so every string `extends` target
- * is a file path or an npm package.
- */
-export const resolveNamedRuleset = (name, basePath = process.cwd()) => {
-    if (name.startsWith('.') || isAbsolute(name)) {
-        const file = resolvePath(basePath, name);
-        return { definition: loadRulesetFile(file), basePath: dirname(file) };
-    }
-    let file;
-    try {
-        file = require.resolve(name, { paths: [basePath] });
-    }
-    catch {
-        throw new Error(`Cannot resolve extended ruleset "${name}" from ${basePath}`);
-    }
-    return { definition: loadRulesetFile(file), basePath: dirname(file) };
+const resolveNamedRuleset = (name, basePath = process.cwd()) => {
+  if (name.startsWith(".") || isAbsolute(name)) {
+    const file2 = resolvePath(basePath, name);
+    return { definition: loadRulesetFile(file2), basePath: dirname(file2) };
+  }
+  let file;
+  try {
+    file = require2.resolve(name, { paths: [basePath] });
+  } catch {
+    throw new Error(`Cannot resolve extended ruleset "${name}" from ${basePath}`);
+  }
+  return { definition: loadRulesetFile(file), basePath: dirname(file) };
 };
-/** Loads a single custom function module (`<dir>/<name>.{js,cjs,mjs}` or a bare path). */
 const loadFunctionByName = (basePath, dir, name) => {
-    const baseFile = resolvePath(basePath, dir, name);
-    for (const candidate of [baseFile, `${baseFile}.js`, `${baseFile}.cjs`, `${baseFile}.mjs`]) {
-        try {
-            const resolvedFile = require.resolve(candidate);
-            const module = require(resolvedFile);
-            const fn = module.default ?? module;
-            if (typeof fn !== 'function')
-                throw new Error(`"${name}" did not export a function`);
-            return fn;
-        }
-        catch (error) {
-            if (error.code !== 'MODULE_NOT_FOUND')
-                throw error;
-        }
+  const baseFile = resolvePath(basePath, dir, name);
+  for (const candidate of [baseFile, `${baseFile}.js`, `${baseFile}.cjs`, `${baseFile}.mjs`]) {
+    try {
+      const resolvedFile = require2.resolve(candidate);
+      const module = require2(resolvedFile);
+      const fn = module.default ?? module;
+      if (typeof fn !== "function")
+        throw new Error(`"${name}" did not export a function`);
+      return fn;
+    } catch (error) {
+      if (error.code !== "MODULE_NOT_FOUND")
+        throw error;
     }
-    throw new Error(`Cannot resolve custom function "${name}" from ${resolvePath(basePath, dir)}`);
+  }
+  throw new Error(`Cannot resolve custom function "${name}" from ${resolvePath(basePath, dir)}`);
 };
-/**
- * Walks a ruleset definition (and its string `extends`) collecting custom
- * functions declared via `functions` / `functionsDir`, each loaded relative to
- * the directory of the ruleset that declared it. YAML/JSON rulesets reference
- * functions by name; JS rulesets can instead pass direct references in `then`.
- */
-const collectCustomFunctions = (definition, basePath, into, 
-// Keyed by (basePath, reference) for string extends and by object identity for
-// inline ones. `loadRulesetFile` returns a fresh object per read, so object
-// identity alone would never dedupe a file cycle — we key on the resolved edge.
-seen) => {
-    if (seen.has(definition))
-        return;
-    seen.add(definition);
-    if (definition.extends) {
-        const entries = Array.isArray(definition.extends) ? definition.extends : [definition.extends];
-        for (const entry of entries) {
-            const target = Array.isArray(entry) ? entry[0] : entry;
-            if (typeof target === 'string') {
-                const key = `${basePath}\0${target}`;
-                if (seen.has(key))
-                    continue;
-                seen.add(key);
-                const resolved = resolveNamedRuleset(target, basePath);
-                collectCustomFunctions(resolved.definition, resolved.basePath, into, seen);
-            }
-            else {
-                collectCustomFunctions(target, basePath, into, seen);
-            }
-        }
-    }
-    if (Array.isArray(definition.functions)) {
-        const dir = definition.functionsDir ?? 'functions';
-        for (const name of definition.functions)
-            into[name] = loadFunctionByName(basePath, dir, name);
+const collectCustomFunctions = (definition, basePath, into, seen) => {
+  if (seen.has(definition))
+    return;
+  seen.add(definition);
+  if (definition.extends) {
+    const entries = Array.isArray(definition.extends) ? definition.extends : [definition.extends];
+    for (const entry of entries) {
+      const target = Array.isArray(entry) ? entry[0] : entry;
+      if (typeof target === "string") {
+        const key = `${basePath}\0${target}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        const resolved = resolveNamedRuleset(target, basePath);
+        collectCustomFunctions(resolved.definition, resolved.basePath, into, seen);
+      } else {
+        collectCustomFunctions(target, basePath, into, seen);
+      }
     }
+  }
+  if (Array.isArray(definition.functions)) {
+    const dir = definition.functionsDir ?? "functions";
+    for (const name of definition.functions)
+      into[name] = loadFunctionByName(basePath, dir, name);
+  }
 };
-/**
- * Builds a runnable {@link Ruleset} from a ruleset definition, layering the
- * built-in functions (plus any custom ones the definition declares via
- * `functions` / `functionsDir`) over the core engine and wiring up `extends`
- * resolution against files and npm packages. With no definition it produces an
- * empty ruleset (no rules run).
- */
-export const createRuleset = (definition, basePath) => {
-    const resolved = definition ?? {};
-    // Custom functions referenced by name (YAML/JSON rulesets) are loaded relative
-    // to the declaring ruleset's directory and layered over the built-ins.
-    let functions = builtinFunctions;
-    const custom = {};
-    collectCustomFunctions(resolved, basePath ?? process.cwd(), custom, new Set());
-    if (Object.keys(custom).length > 0)
-        functions = { ...builtinFunctions, ...custom };
-    return createCoreRuleset(resolved, {
-        functions,
-        resolve: resolveNamedRuleset,
-        ...(basePath !== undefined ? { basePath } : {}),
-    });
+const createRuleset = (definition, basePath) => {
+  const resolved = definition ?? {};
+  let functions = builtinFunctions;
+  const custom = {};
+  collectCustomFunctions(resolved, basePath ?? process.cwd(), custom, /* @__PURE__ */ new Set());
+  if (Object.keys(custom).length > 0)
+    functions = { ...builtinFunctions, ...custom };
+  return createCoreRuleset(resolved, {
+    functions,
+    resolve: resolveNamedRuleset,
+    ...basePath !== void 0 ? { basePath } : {}
+  });
 };
-/**
- * Lints a JSON/YAML `input` end to end: parses with source maps and applies the
- * ruleset. Returns just the findings; use {@link lintDocumentWithResult} for the
- * full result.
- */
-export const lintDocument = async (input, options = {}) => (await lintDocumentWithResult(input, options)).diagnostics;
-/**
- * Like {@link lintDocument}, but returns the full {@link ILintResult} — including
- * anything the configured `plugins` produced (e.g. the auto-fix plugin's
- * rewritten `output`).
- */
-export const lintDocumentWithResult = async (input, options = {}) => {
-    const { ruleset: rulesetDefinition, rulesetBasePath, resolve, plugins, ...documentOptions } = options;
-    const ruleset = createRuleset(rulesetDefinition, rulesetBasePath);
-    return lintWithResult(input, {
-        ...documentOptions,
-        ruleset,
-        ...(resolve ? { resolve } : {}),
-        ...(plugins ? { plugins } : {}),
-    });
+const lintDocument = async (input, options = {}) => (await lintDocumentWithResult(input, options)).diagnostics;
+const lintDocumentWithResult = async (input, options = {}) => {
+  const { ruleset: rulesetDefinition, rulesetBasePath, resolve, plugins, ...documentOptions } = options;
+  const ruleset = createRuleset(rulesetDefinition, rulesetBasePath);
+  return lintWithResult(input, {
+    ...documentOptions,
+    ruleset,
+    ...resolve ? { resolve } : {},
+    ...plugins ? { plugins } : {}
+  });
 };
-// One fix pass can unblock the next, so we lint-and-fix to a fixpoint. The cap is
-// a safety net against a fixer that oscillates rather than converging — in
-// practice a couple of passes is plenty.
 const MAX_FIX_PASSES = 10;
-/**
- * Lints a document and applies the supplied `fixers` repeatedly until the
- * document stops changing (or {@link MAX_FIX_PASSES} is reached), then re-lints
- * so `remaining` reflects the fixed document. A one-call convenience over
- * {@link lintDocumentWithResult} + `createFixPlugin`. With no `fixers` this is a
- * no-op that just returns the findings.
- */
-export const fixDocument = async (input, options = {}) => {
-    const { fixers = {}, safeOnly, ...lintOptions } = options;
-    const plugin = createFixPlugin(fixers, { safeOnly: safeOnly !== false });
-    let current = input;
-    const applied = [];
-    for (let pass = 0; pass < MAX_FIX_PASSES; pass++) {
-        const result = await lintDocumentWithResult(current, { ...lintOptions, plugins: [plugin] });
-        // No rewrite, or a rewrite that matches what we already have, means we have converged.
-        if (result.output === undefined || result.output === current)
-            break;
-        current = result.output;
-        const data = result.pluginData[FIX_PLUGIN_NAME];
-        if (data)
-            applied.push(...data.applied);
-    }
-    const remaining = await lintDocument(current, lintOptions);
-    return { output: current, fixed: applied.length > 0, remaining, applied };
+const fixDocument = async (input, options = {}) => {
+  const { fixers = {}, safeOnly, ...lintOptions } = options;
+  const plugin = createFixPlugin(fixers, { safeOnly: safeOnly !== false });
+  let current = input;
+  const applied = [];
+  for (let pass = 0; pass < MAX_FIX_PASSES; pass++) {
+    const result = await lintDocumentWithResult(current, { ...lintOptions, plugins: [plugin] });
+    if (result.output === void 0 || result.output === current)
+      break;
+    current = result.output;
+    const data = result.pluginData[FIX_PLUGIN_NAME];
+    if (data)
+      applied.push(...data.applied);
+  }
+  const remaining = await lintDocument(current, lintOptions);
+  return { output: current, fixed: applied.length > 0, remaining, applied };
+};
+export {
+  FIX_PLUGIN_NAME2 as FIX_PLUGIN_NAME,
+  alphabetical,
+  applyFixes,
+  builtinFunctions2 as builtinFunctions,
+  casing,
+  compileQuery,
+  createDocument,
+  createFixPlugin2 as createFixPlugin,
+  createLinter,
+  createRuleset,
+  defined,
+  detectFormat,
+  detectFormats,
+  enumeration,
+  falsy,
+  fixDocument,
+  globToRegExp,
+  length,
+  lint,
+  lintDocument,
+  lintDocumentWithResult,
+  lintWithResult2 as lintWithResult,
+  matchesGlob,
+  or,
+  parseWithPointers2 as parseWithPointers,
+  pattern,
+  pointerToPath,
+  query,
+  queryCompiled,
+  queryMany,
+  resolveNamedRuleset,
+  resolveSourceOrigin,
+  resolveSourceOriginFromMap,
+  resolveSourcePath,
+  runPlugins,
+  schema,
+  truthy,
+  typedEnum,
+  undefinedFn,
+  unreferencedReusableObject,
+  validateRuleset,
+  xor
 };