@amritk/lint 0.3.1 → 0.3.3

package/dist/functions/typed-enum.js

@@ -1,40 +1,37 @@
 const JS_TYPES = {
-    string: (v) => typeof v === 'string',
-    number: (v) => typeof v === 'number',
-    integer: (v) => typeof v === 'number' && Number.isInteger(v),
-    boolean: (v) => typeof v === 'boolean',
-    null: (v) => v === null,
-    array: (v) => Array.isArray(v),
-    object: (v) => typeof v === 'object' && v !== null && !Array.isArray(v),
+  string: (v) => typeof v === "string",
+  number: (v) => typeof v === "number",
+  integer: (v) => typeof v === "number" && Number.isInteger(v),
+  boolean: (v) => typeof v === "boolean",
+  null: (v) => v === null,
+  array: (v) => Array.isArray(v),
+  object: (v) => typeof v === "object" && v !== null && !Array.isArray(v)
 };
-/** Validates that each `enum` entry matches the schema's declared `type`. */
-export const typedEnum = (input, _options, context) => {
-    if (typeof input !== 'object' || input === null)
-        return [];
-    const declaredType = input['type'];
-    const values = input['enum'];
-    if (declaredType === undefined || !Array.isArray(values))
-        return [];
-    const types = Array.isArray(declaredType) ? [...declaredType] : [declaredType];
-    // A schema marked nullable (OpenAPI 3 `nullable` or the Swagger 2 `x-nullable`
-    // vendor extension) is allowed to hold `null` in addition to its declared
-    // type, so `null` must not be flagged as a type mismatch.
-    if ((input['nullable'] === true || input['x-nullable'] === true) && !types.includes('null')) {
-        types.push('null');
+const typedEnum = (input, _options, context) => {
+  if (typeof input !== "object" || input === null)
+    return [];
+  const declaredType = input["type"];
+  const values = input["enum"];
+  if (declaredType === void 0 || !Array.isArray(values))
+    return [];
+  const types = Array.isArray(declaredType) ? [...declaredType] : [declaredType];
+  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));
+  if (checkers.length === 0)
+    return [];
+  const results = [];
+  values.forEach((value, index) => {
+    if (!checkers.some((check) => check(value))) {
+      results.push({
+        message: `Enum value \`${JSON.stringify(value)}\` must be of type "${types.join(" | ")}"`,
+        path: [...context.path, "enum", index]
+      });
     }
-    const checkers = types
-        .map((type) => JS_TYPES[String(type)])
-        .filter((fn) => Boolean(fn));
-    if (checkers.length === 0)
-        return [];
-    const results = [];
-    values.forEach((value, index) => {
-        if (!checkers.some((check) => check(value))) {
-            results.push({
-                message: `Enum value \`${JSON.stringify(value)}\` must be of type "${types.join(' | ')}"`,
-                path: [...context.path, 'enum', index],
-            });
-        }
-    });
-    return results;
+  });
+  return results;
+};
+export {
+  typedEnum
 };

package/dist/functions/undefined.js

@@ -1,9 +1,8 @@
-/**
- * Flags a value that is defined. Exported as `undefinedFn` because `undefined`
- * is a reserved identifier; it is registered under the name `undefined`.
- */
-export const undefinedFn = (input) => {
-    if (input !== undefined)
-        return [{ message: 'The value must be undefined' }];
-    return [];
+const undefinedFn = (input) => {
+  if (input !== void 0)
+    return [{ message: "The value must be undefined" }];
+  return [];
+};
+export {
+  undefinedFn
 };

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

@@ -1,52 +1,40 @@
-/** Collects every `$ref` string anywhere in `node` into `into`. */
 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);
-        }
+  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);
     }
+  }
 };
-/** Escapes a key for use in a JSON pointer segment (`~` -> `~0`, `/` -> `~1`). */
-const escapePointerSegment = (key) => key.replace(/~/g, '~0').replace(/\//g, '~1');
-/**
- * Flags entries in a reusable-object map that nothing `$ref`s.
- *
- * This must run against the *unresolved* document: once `$ref`s are inlined by a
- * resolver there are no references left to count, so every reusable object would
- * look orphaned.
- */
-export const unreferencedReusableObject = (input, options, context) => {
-    if (typeof input !== 'object' || input === null)
-        return [];
-    const location = options?.reusableObjectsLocation;
-    if (!location)
-        return [];
-    const refs = new Set();
-    collectRefs(context.document.data, refs);
-    const results = [];
-    for (const key of Object.keys(input)) {
-        // A key such as "a/b" appears in a pointer as "a~1b", so escape it before
-        // building the expected reference. Without this a legitimately referenced
-        // object with a special character in its name looks unreferenced.
-        const base = `${location}/${escapePointerSegment(key)}`;
-        // A reference can point straight at the object (`base`) or deeper into it
-        // (e.g. `base/properties/x`); either counts as a use, so match the exact
-        // pointer or any pointer nested beneath it.
-        const referenced = refs.has(base) || [...refs].some((ref) => ref.startsWith(`${base}/`));
-        if (!referenced) {
-            results.push({
-                message: 'This reusable object is never referenced',
-                path: [...context.path, key],
-            });
-        }
+const escapePointerSegment = (key) => key.replace(/~/g, "~0").replace(/\//g, "~1");
+const unreferencedReusableObject = (input, options, context) => {
+  if (typeof input !== "object" || input === null)
+    return [];
+  const location = options?.reusableObjectsLocation;
+  if (!location)
+    return [];
+  const refs = /* @__PURE__ */ new Set();
+  collectRefs(context.document.data, refs);
+  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) {
+      results.push({
+        message: "This reusable object is never referenced",
+        path: [...context.path, key]
+      });
     }
-    return results;
+  }
+  return results;
+};
+export {
+  unreferencedReusableObject
 };

package/dist/functions/xor.js

@@ -1,18 +1,15 @@
-/** Flags an object unless exactly one of the listed `properties` is present. */
-export const xor = (input, options) => {
-    if (typeof input !== 'object' || input === null)
-        return [];
-    const properties = options?.properties;
-    // Spectral validates the option schema (an array of at least two strings)
-    // before the function runs and no-ops when it fails, so with fewer than two
-    // properties there is nothing meaningful to check. We deliberately skip in
-    // silence rather than push an error: an empty or single-element list would
-    // otherwise flag every node with a message that names nothing useful.
-    if (!Array.isArray(properties) || properties.length < 2)
-        return [];
-    const present = properties.filter((property) => property in input);
-    if (present.length !== 1) {
-        return [{ message: `Exactly one of ${properties.map((p) => `"${p}"`).join(', ')} must be defined` }];
-    }
+const xor = (input, options) => {
+  if (typeof input !== "object" || input === null)
     return [];
+  const properties = options?.properties;
+  if (!Array.isArray(properties) || properties.length < 2)
+    return [];
+  const present = properties.filter((property) => property in input);
+  if (present.length !== 1) {
+    return [{ message: `Exactly one of ${properties.map((p) => `"${p}"`).join(", ")} must be defined` }];
+  }
+  return [];
+};
+export {
+  xor
 };

package/dist/index.js

@@ -1,176 +1,126 @@
-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";
+export * from "./core/index.js";
+export * from "./fix/index.js";
+export * 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 {
+  createRuleset,
+  detectFormat,
+  fixDocument,
+  lintDocument,
+  lintDocumentWithResult,
+  parseWithPointers2 as parseWithPointers,
+  resolveNamedRuleset
 };