@amritk/lint 0.4.8 → 0.5.0

package/dist/core/severity.d.ts

@@ -0,0 +1,11 @@
+import { DiagnosticSeverity } from '../parsers/index.js';
+/**
+ * Resolves a severity name, or `undefined` when it is not one we know.
+ *
+ * `ownKey`, never a bare index or `in`: these names come from rulesets, so
+ * `severity: 'constructor'` otherwise resolved to `Object` itself — and a
+ * severity that is a function is neither `'off'` nor `undefined`, so it sailed
+ * past both fallbacks and every later comparison against
+ * `DiagnosticSeverity.Error` read false.
+ */
+export declare const severityFromName: (name: string) => DiagnosticSeverity | 'off' | undefined;

package/dist/core/severity.js

@@ -0,0 +1,13 @@
+import { DiagnosticSeverity } from "../parsers/index.js";
+import { ownKey } from "./own-key.js";
+const SEVERITY_NAMES = {
+  error: DiagnosticSeverity.Error,
+  warn: DiagnosticSeverity.Warning,
+  info: DiagnosticSeverity.Information,
+  hint: DiagnosticSeverity.Hint,
+  off: "off"
+};
+const severityFromName = (name) => ownKey(SEVERITY_NAMES, name);
+export {
+  severityFromName
+};

package/dist/fix/apply.js

@@ -19,7 +19,12 @@ const applyFixes = (input, format, data, diagnostics, fixers, options = {}) => {
       continue;
     if (safeOnly && fixer.safe === false)
       continue;
-    const produced = fixer.fix({ diagnostic, data, format });
+    let produced;
+    try {
+      produced = fixer.fix({ diagnostic, data, format });
+    } catch {
+      continue;
+    }
     if (!produced)
       continue;
     const ops2 = Array.isArray(produced) ? produced : [produced];

package/dist/fix/plugin.js

@@ -3,7 +3,8 @@ const FIX_PLUGIN_NAME = "fix";
 const createFixPlugin = (fixers, options = {}) => ({
   name: FIX_PLUGIN_NAME,
   afterLint: (diagnostics, context) => {
-    const result = applyFixes(context.input, context.format, context.document.data, diagnostics, fixers, options);
+    const own = diagnostics.filter((diagnostic) => diagnostic.source === context.source);
+    const result = applyFixes(context.input, context.format, context.document.data, own, fixers, options);
     if (!result.changed)
       return void 0;
     const data = { applied: result.applied };

package/dist/functions/or.js

@@ -4,7 +4,7 @@ const or = (input, options) => {
   const properties = options?.properties;
   if (!Array.isArray(properties) || properties.length < 2)
     return [];
-  const present = properties.filter((property) => property in input);
+  const present = properties.filter((property) => Object.hasOwn(input, property));
   if (present.length > 0)
     return [];
   if (properties.length > 4) {

package/dist/functions/ref-index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Indexes every `$ref` target in a document, plus each of its `/`-delimited
+ * ancestors, so "is this reusable object referenced?" is a single set lookup.
+ *
+ * A component counts as used when a `$ref` targets it *or* points into it
+ * (`#/components/schemas/Pet/properties/id` still uses `Pet`). Testing that
+ * per component meant scanning every ref for a prefix match — O(components ×
+ * refs), and the unreferenced-object rule copied the whole ref set into a fresh
+ * array on each component to do it. Recording the ancestors once turns the whole
+ * rule into O(refs + components).
+ *
+ * Shared by `unreferencedReusableObject` and the OpenAPI `oasUnusedComponent`,
+ * which had a byte-identical copy of the walk between them.
+ */
+export declare const collectReferencedPointers: (document: unknown) => Set<string>;

package/dist/functions/ref-index.js

@@ -0,0 +1,33 @@
+const collectReferencedPointers = (document) => {
+  const pointers = /* @__PURE__ */ new Set();
+  const add = (ref) => {
+    pointers.add(ref);
+    for (let slash = ref.lastIndexOf("/"); slash > 0; slash = ref.lastIndexOf("/", slash - 1)) {
+      const prefix = ref.slice(0, slash);
+      if (pointers.has(prefix))
+        return;
+      pointers.add(prefix);
+    }
+  };
+  const stack = [document];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (Array.isArray(node)) {
+      for (const item of node)
+        stack.push(item);
+      continue;
+    }
+    if (typeof node !== "object" || node === null)
+      continue;
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "$ref" && typeof value === "string")
+        add(value);
+      else
+        stack.push(value);
+    }
+  }
+  return pointers;
+};
+export {
+  collectReferencedPointers
+};

package/dist/functions/schema.d.ts

@@ -16,6 +16,21 @@ export type ISchemaOptions = {
      * without the caller naming a dialect.
      */
     dialect?: string;
+    /**
+     * Report nothing when the schema itself cannot be built or run, instead of
+     * reporting why.
+     *
+     * The default suits a schema written in the *ruleset*: if that one is
+     * unusable, its author wants to hear about it. A schema taken from the
+     * *document* — a message payload, a parameter's schema — is different. It can
+     * legitimately carry a `$ref` this package cannot resolve (an external file, or
+     * anything at all when no resolver was injected), and there the validator's own
+     * complaint is not a finding about the document: it is an error-severity
+     * diagnostic, on a valid document, whose text describes this package's API.
+     * Callers validating document-supplied schemas pass `true` and get silence
+     * where they cannot judge.
+     */
+    skipUnusableSchema?: boolean;
 };
 /** Validates a value against a JSON Schema supplied in the rule's options. */
 export declare const schema: RulesetFunction<unknown, ISchemaOptions>;

package/dist/functions/schema.js

@@ -83,6 +83,8 @@ const schema = (input, options, context) => {
   try {
     result = getValidator(options.schema)(input);
   } catch (error) {
+    if (options.skipUnusableSchema)
+      return [];
     return [
       {
         message: `Invalid schema: ${error instanceof Error ? error.message : String(error)}`,

package/dist/functions/typed-enum.js

@@ -1,3 +1,4 @@
+import { ownKey } from "../core/own-key.js";
 const JS_TYPES = {
   string: (v) => typeof v === "string",
   number: (v) => typeof v === "number",
@@ -18,7 +19,7 @@ const typedEnum = (input, _options, context) => {
   if ((input["nullable"] === true || input["x-nullable"] === true) && !types.includes("null")) {
     types.push("null");
   }
-  const checkers = types.map((type) => JS_TYPES[String(type)]).filter((fn) => Boolean(fn));
+  const checkers = types.map((type) => ownKey(JS_TYPES, String(type))).filter((fn) => fn !== void 0);
   if (checkers.length === 0)
     return [];
   const results = [];

package/dist/functions/unreferenced-reusable-object.js

@@ -1,18 +1,4 @@
-const collectRefs = (node, into) => {
-  if (Array.isArray(node)) {
-    for (const item of node)
-      collectRefs(item, into);
-    return;
-  }
-  if (typeof node === "object" && node !== null) {
-    for (const [key, value] of Object.entries(node)) {
-      if (key === "$ref" && typeof value === "string")
-        into.add(value);
-      else
-        collectRefs(value, into);
-    }
-  }
-};
+import { collectReferencedPointers } from "./ref-index.js";
 const escapePointerSegment = (key) => key.replace(/~/g, "~0").replace(/\//g, "~1");
 const unreferencedReusableObject = (input, options, context) => {
   if (typeof input !== "object" || input === null)
@@ -20,13 +6,10 @@ const unreferencedReusableObject = (input, options, context) => {
   const location = options?.reusableObjectsLocation;
   if (!location)
     return [];
-  const refs = /* @__PURE__ */ new Set();
-  collectRefs(context.document.data, refs);
+  const referenced = collectReferencedPointers(context.document.data);
   const results = [];
   for (const key of Object.keys(input)) {
-    const base = `${location}/${escapePointerSegment(key)}`;
-    const referenced = refs.has(base) || [...refs].some((ref) => ref.startsWith(`${base}/`));
-    if (!referenced) {
+    if (!referenced.has(`${location}/${escapePointerSegment(key)}`)) {
       results.push({
         message: "This reusable object is never referenced",
         path: [...context.path, key]

package/dist/functions/xor.js

@@ -4,7 +4,7 @@ const xor = (input, options) => {
   const properties = options?.properties;
   if (!Array.isArray(properties) || properties.length < 2)
     return [];
-  const present = properties.filter((property) => property in input);
+  const present = properties.filter((property) => Object.hasOwn(input, property));
   if (present.length !== 1) {
     return [{ message: `Exactly one of ${properties.map((p) => `"${p}"`).join(", ")} must be defined` }];
   }

package/dist/index.d.ts

@@ -1,24 +1,12 @@
 import { type IDocumentOptions, type LintPlugin, type LintResolver, type ResolvedExtend, type Ruleset } from './core/index.js';
 import type { IDiagnostic, RulesetDefinition } from './core/types.js';
 import { type AppliedFix, type FixerRegistry } from './fix/index.js';
+import { type IRulesetTrustOptions } from './ruleset-files.js';
 export { type AliasDefinition, type CompiledPath, compileQuery, createDocument, createLinter, type Document, detectFormats, type ExtendModifier, type ExtendResolver, type Format, globToRegExp, type IDocumentOptions, type IQueryMatch, type IRulesetProblem, type IRunOptions, type Linter, type LintOptions, type LintPlugin, type LintPluginContext, type LintPluginResult, type LintResolver, type LintResolverResult, type LintResult, lint, lintWithResult, matchesGlob, type PluginRunResult, pointerToPath, query, queryCompiled, queryMany, type ResolvedExtend, type Ruleset, type RulesetOptions, resolveSourceOrigin, resolveSourceOriginFromMap, resolveSourcePath, runPlugins, validateRuleset, } from './core/index.js';
 export { type AppliedFix, type ApplyFixesOptions, applyFixes, createFixPlugin, type EditOp, FIX_PLUGIN_NAME, type FixContext, type Fixer, type FixerRegistry, type FixPluginData, type FixResult, type ParserFormat, } from './fix/index.js';
 export { alphabetical, builtinFunctions, type CasingType, casing, defined, enumeration, falsy, type IAlphabeticalOptions, type ICasingOptions, type IOrOptions, type ISchemaOptions, type IUnreferencedReusableObjectOptions, type IXorOptions, length, or, pattern, schema, truthy, typedEnum, undefinedFn, unreferencedReusableObject, xor, } from './functions/index.js';
 export { detectFormat, parseWithPointers } from './parsers/index.js';
-/**
- * An optional directory that everything a ruleset pulls off disk — `extends`
- * targets and custom function modules — must resolve inside.
- *
- * This is opt-in and off by default, because `basePath` on its own is only a
- * *resolution origin*: an `extends` of `/etc/thing.js` or `../../../elsewhere`
- * resolves and loads exactly as written. See the "Trust boundary" section of the
- * README — a ruleset that can name a `.js` file can run code, restricted root or
- * not. This narrows *which* files it can name; it is not a sandbox.
- */
-export type IRulesetTrustOptions = {
-    /** Directory that `extends` files and custom functions must resolve under. */
-    restrictTo?: string;
-};
+export type { IRulesetTrustOptions } from './ruleset-files.js';
 /**
  * Resolves an `extends` reference to a ruleset definition. Supports:
  * - local file paths (relative to `basePath`, or absolute): `.yaml` / `.yml` / `.json` / `.js`,
@@ -49,8 +37,20 @@ export declare const resolveNamedRuleset: (name: string, basePath?: string, opti
 export declare const createRuleset: (definition?: RulesetDefinition, basePath?: string, options?: IRulesetTrustOptions) => Ruleset;
 /** Options for {@link lintDocument}: the document options plus ruleset controls. */
 export type ILintOptions = IDocumentOptions & {
-    /** The ruleset definition to evaluate. When omitted, no rules run. */
-    ruleset?: RulesetDefinition;
+    /**
+     * The rules to evaluate: either a definition to build with the built-in
+     * functions, or a {@link Ruleset} that is already built. When omitted, no rules
+     * run.
+     *
+     * Pass a built one to use a preset that brings its own functions and format
+     * detectors — `createOpenApiRuleset()` from `@amritk/lint/rules/openapi`, say.
+     * A definition alone cannot express those, so an OpenAPI ruleset handed over as
+     * data would have every rule skipped: its functions are unknown here, and its
+     * `formats` gate matches nothing against an empty format registry.
+     * `rulesetBasePath` and `restrictTo` only apply while *building*, so they are
+     * ignored for a ruleset that already is.
+     */
+    ruleset?: RulesetDefinition | Ruleset;
     /** Directory that the ruleset's string `extends` references resolve relative to. */
     rulesetBasePath?: string;
     /**

package/dist/index.js

@@ -1,99 +1,26 @@
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, isAbsolute, resolve as resolvePath, sep } from "node:path";
 import { createBoundedCache, 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 { 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 { 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 = require2(file);
-  return module.default ?? module;
-};
-const assertWithinRoot = (file, restrictTo, what) => {
-  if (restrictTo === void 0)
-    return;
-  const root = resolvePath(restrictTo);
-  const resolved = resolvePath(file);
-  if (resolved !== root && !resolved.startsWith(root.endsWith(sep) ? root : `${root}${sep}`)) {
-    throw new Error(`${what} "${file}" resolves outside the permitted root ${root}`);
-  }
-};
-const resolveNamedRuleset = (name, basePath = process.cwd(), options = {}) => {
-  if (name.startsWith(".") || isAbsolute(name)) {
-    const file2 = resolvePath(basePath, name);
-    assertWithinRoot(file2, options.restrictTo, "Extended ruleset");
-    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}`);
-  }
-  assertWithinRoot(file, options.restrictTo, "Extended ruleset");
-  return { definition: loadRulesetFile(file), basePath: dirname(file) };
-};
-const loadFunctionByName = (basePath, dir, name, restrictTo) => {
-  const baseFile = resolvePath(basePath, dir, name);
-  assertWithinRoot(baseFile, restrictTo, "Custom function");
-  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)}`);
-};
-const collectCustomFunctions = (definition, basePath, into, seen, restrictTo) => {
-  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, { ...restrictTo !== void 0 ? { restrictTo } : {} });
-        collectCustomFunctions(resolved.definition, resolved.basePath, into, seen, restrictTo);
-      } else {
-        collectCustomFunctions(target, basePath, into, seen, restrictTo);
-      }
-    }
-  }
-  if (Array.isArray(definition.functions)) {
-    const dir = definition.functionsDir ?? "functions";
-    for (const name of definition.functions)
-      into[name] = loadFunctionByName(basePath, dir, name, restrictTo);
-  }
-};
+import { detectFormat, parseWithPointers } from "./parsers/index.js";
+const resolveNamedRuleset = (name, basePath = process.cwd(), options = {}) => resolveRulesetFile(name, basePath, options);
 const buildRuleset = (definition, basePath, restrictTo) => {
+  const trust = restrictTo !== void 0 ? { restrictTo } : {};
+  const resolve = (name, from) => resolveNamedRuleset(name, from, trust);
   let functions = builtinFunctions;
   const custom = {};
-  collectCustomFunctions(definition, basePath ?? process.cwd(), custom, /* @__PURE__ */ new Set(), restrictTo);
+  collectCustomFunctions(definition, basePath ?? process.cwd(), custom, /* @__PURE__ */ new Set(), {
+    ...trust,
+    resolveExtend: resolve
+  });
   if (Object.keys(custom).length > 0)
     functions = { ...builtinFunctions, ...custom };
   return createCoreRuleset(definition, {
     functions,
-    resolve: (name, from) => resolveNamedRuleset(name, from, { ...restrictTo !== void 0 ? { restrictTo } : {} }),
+    resolve,
     ...basePath !== void 0 ? { basePath } : {}
   });
 };
@@ -102,6 +29,9 @@ const emptyRulesets = createBoundedCache(16);
 const createRuleset = (definition, basePath, options = {}) => {
   const { restrictTo } = options;
   const key = `${restrictTo ?? ""}\0${basePath ?? process.cwd()}`;
+  if (definition !== void 0 && (typeof definition !== "object" || definition === null)) {
+    return buildRuleset(definition, basePath, restrictTo);
+  }
   if (definition === void 0) {
     const cached2 = emptyRulesets.get(key);
     if (cached2)
@@ -122,13 +52,16 @@ const createRuleset = (definition, basePath, options = {}) => {
   byBasePath.set(key, built);
   return built;
 };
+const isBuiltRuleset = (ruleset) => typeof ruleset.getFunction === "function";
 const lintDocument = async (input, options = {}) => (await lintDocumentWithResult(input, options)).diagnostics;
 const lintDocumentWithResult = async (input, options = {}) => {
-  const { ruleset: rulesetDefinition, rulesetBasePath, restrictTo, ...rest } = options;
-  const ruleset = createRuleset(rulesetDefinition, rulesetBasePath, {
-    ...restrictTo !== void 0 ? { restrictTo } : {}
-  });
-  return runLint(input, ruleset, rest);
+  const { ruleset, rulesetBasePath, restrictTo, ...rest } = options;
+  return runLint(input, toRuleset(ruleset, rulesetBasePath, restrictTo), rest);
+};
+const toRuleset = (ruleset, basePath, restrictTo) => {
+  if (ruleset !== void 0 && isBuiltRuleset(ruleset))
+    return ruleset;
+  return createRuleset(ruleset, basePath, { ...restrictTo !== void 0 ? { restrictTo } : {} });
 };
 const runLint = async (input, ruleset, options) => {
   const { resolve, plugins, ...documentOptions } = options;
@@ -142,11 +75,9 @@ const runLint = async (input, ruleset, options) => {
 const appliedKey = (fix) => `${fix.code}\0${fix.path.map((segment) => typeof segment === "number" ? `[${segment}]` : `.${segment}`).join("")}`;
 const MAX_FIX_PASSES = 10;
 const fixDocument = async (input, options = {}) => {
-  const { fixers = {}, safeOnly, ruleset: rulesetDefinition, rulesetBasePath, restrictTo, ...lintOptions } = options;
+  const { fixers = {}, safeOnly, ruleset: rulesetOption, rulesetBasePath, restrictTo, ...lintOptions } = options;
   const plugin = createFixPlugin(fixers, { safeOnly: safeOnly !== false });
-  const ruleset = createRuleset(rulesetDefinition, rulesetBasePath, {
-    ...restrictTo !== void 0 ? { restrictTo } : {}
-  });
+  const ruleset = toRuleset(rulesetOption, rulesetBasePath, restrictTo);
   let current = input;
   let passes = 0;
   let converged = false;
@@ -199,7 +130,7 @@ export {
   lintWithResult2 as lintWithResult,
   matchesGlob,
   or,
-  parseWithPointers2 as parseWithPointers,
+  parseWithPointers,
   pattern,
   pointerToPath,
   query,

package/dist/rules/asyncapi/asyncapi.d.ts

@@ -0,0 +1,3 @@
+import type { RulesetDefinition } from '../../core/types.js';
+/** Loupe's built-in AsyncAPI ruleset (`loupe:asyncapi`). */
+export declare const asyncapi: RulesetDefinition;