@amritk/lint 0.3.2 → 0.4.0

package/dist/rules/openapi/functions/oas-tag-parent-defined.js

@@ -1,45 +1,42 @@
-import { isObject } from './helpers.js';
-/**
- * Validates the OpenAPI 3.2 Tag Object `parent` hierarchy: every `parent` must
- * name a tag that exists in the top-level `tags` list, a tag must not be its own
- * parent, and the parent chain must not form a cycle.
- */
-export const oasTagParentDefined = (tags, _options, context) => {
-    if (!Array.isArray(tags))
-        return [];
-    const byName = new Map();
-    for (const tag of tags) {
-        if (isObject(tag) && typeof tag['name'] === 'string')
-            byName.set(tag['name'], tag);
+import { isObject } from "./helpers.js";
+const oasTagParentDefined = (tags, _options, context) => {
+  if (!Array.isArray(tags))
+    return [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    if (isObject(tag) && typeof tag["name"] === "string")
+      byName.set(tag["name"], tag);
+  }
+  const results = [];
+  tags.forEach((tag, index) => {
+    if (!isObject(tag) || typeof tag["parent"] !== "string")
+      return;
+    const parent = tag["parent"];
+    const name = typeof tag["name"] === "string" ? tag["name"] : void 0;
+    if (!byName.has(parent)) {
+      results.push({
+        message: `Tag parent "${parent}" is not defined in the global tags`,
+        path: [...context.path, index, "parent"]
+      });
+      return;
     }
-    const results = [];
-    tags.forEach((tag, index) => {
-        if (!isObject(tag) || typeof tag['parent'] !== 'string')
-            return;
-        const parent = tag['parent'];
-        const name = typeof tag['name'] === 'string' ? tag['name'] : undefined;
-        if (!byName.has(parent)) {
-            results.push({
-                message: `Tag parent "${parent}" is not defined in the global tags`,
-                path: [...context.path, index, 'parent'],
-            });
-            return;
-        }
-        // Walk the parent chain from this tag; a repeat means a cycle (incl. self-parent).
-        const visited = new Set(name ? [name] : []);
-        let current = parent;
-        while (current !== undefined) {
-            if (visited.has(current)) {
-                results.push({
-                    message: `Tag "${name ?? '(unnamed)'}" has a circular parent reference via "${current}"`,
-                    path: [...context.path, index, 'parent'],
-                });
-                break;
-            }
-            visited.add(current);
-            const next = byName.get(current)?.['parent'];
-            current = typeof next === 'string' ? next : undefined;
-        }
-    });
-    return results;
+    const visited = new Set(name ? [name] : []);
+    let current = parent;
+    while (current !== void 0) {
+      if (visited.has(current)) {
+        results.push({
+          message: `Tag "${name ?? "(unnamed)"}" has a circular parent reference via "${current}"`,
+          path: [...context.path, index, "parent"]
+        });
+        break;
+      }
+      visited.add(current);
+      const next = byName.get(current)?.["parent"];
+      current = typeof next === "string" ? next : void 0;
+    }
+  });
+  return results;
+};
+export {
+  oasTagParentDefined
 };

package/dist/rules/openapi/functions/oas-tags-unique.d.ts

@@ -1,3 +1,3 @@
-import type { RulesetFunction } from '../../../core/index.js';
+import type { RulesetFunction } from '../../../core/types.js';
 /** Flags duplicate global tag names. */
 export declare const oasTagsUnique: RulesetFunction;

package/dist/rules/openapi/functions/oas-tags-unique.js

@@ -1,17 +1,19 @@
-import { isObject } from './helpers.js';
-/** Flags duplicate global tag names. */
-export const oasTagsUnique = (tags, _options, context) => {
-    if (!Array.isArray(tags))
-        return [];
-    const seen = new Set();
-    const results = [];
-    tags.forEach((tag, index) => {
-        if (!isObject(tag) || typeof tag['name'] !== 'string')
-            return;
-        if (seen.has(tag['name'])) {
-            results.push({ message: `Duplicate tag name "${tag['name']}"`, path: [...context.path, index, 'name'] });
-        }
-        seen.add(tag['name']);
-    });
-    return results;
+import { isObject } from "./helpers.js";
+const oasTagsUnique = (tags, _options, context) => {
+  if (!Array.isArray(tags))
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  tags.forEach((tag, index) => {
+    if (!isObject(tag) || typeof tag["name"] !== "string")
+      return;
+    if (seen.has(tag["name"])) {
+      results.push({ message: `Duplicate tag name "${tag["name"]}"`, path: [...context.path, index, "name"] });
+    }
+    seen.add(tag["name"]);
+  });
+  return results;
+};
+export {
+  oasTagsUnique
 };

package/dist/rules/openapi/functions/oas-unused-component.d.ts

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../../../core/index.js';
+import type { RulesetFunction } from '../../../core/types.js';
 /**
  * Flags reusable `components/*` entries that nothing `$ref`s. Spectral's
  * `oas3-unused-component` checks every reusable component type (not just

package/dist/rules/openapi/functions/oas-unused-component.js

@@ -1,65 +1,55 @@
-import { isObject } from './helpers.js';
-// Reusable component types that are referenced via `$ref` (securitySchemes are
-// referenced by name in `security`, not via `$ref`, so they are excluded).
-// `pathItems` was added in OpenAPI 3.1 (referenced from `webhooks` / `callbacks`).
+import { isObject } from "./helpers.js";
 const REUSABLE_COMPONENT_TYPES = [
-    'schemas',
-    'responses',
-    'parameters',
-    'examples',
-    'requestBodies',
-    'headers',
-    'links',
-    'callbacks',
-    'pathItems',
+  "schemas",
+  "responses",
+  "parameters",
+  "examples",
+  "requestBodies",
+  "headers",
+  "links",
+  "callbacks",
+  "pathItems"
 ];
-/** 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 (isObject(node)) {
-        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 (isObject(node)) {
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "$ref" && typeof value === "string")
+        into.add(value);
+      else
+        collectRefs(value, into);
     }
+  }
 };
-/**
- * Flags reusable `components/*` entries that nothing `$ref`s. Spectral's
- * `oas3-unused-component` checks every reusable component type (not just
- * schemas), so we do too — run on the unresolved document.
- */
-export const oasUnusedComponent = (components, _options, context) => {
-    if (!isObject(components))
-        return [];
-    const refs = new Set();
-    collectRefs(context.document.data, refs);
-    // A component counts as used when a `$ref` targets it OR points *into* it
-    // (e.g. `#/components/schemas/Pet/properties/id` still uses `Pet`), so match by
-    // prefix rather than exact string — an interior ref must not leave the parent
-    // flagged as unused.
-    const isReferenced = (base) => {
-        for (const ref of refs) {
-            if (ref === base || ref.startsWith(`${base}/`))
-                return true;
-        }
-        return false;
-    };
-    const results = [];
-    for (const type of REUSABLE_COMPONENT_TYPES) {
-        const group = components[type];
-        if (!isObject(group))
-            continue;
-        for (const key of Object.keys(group)) {
-            if (!isReferenced(`#/components/${type}/${key}`)) {
-                results.push({ message: 'Potentially unused component has been detected.', path: [...context.path, type, key] });
-            }
-        }
+const oasUnusedComponent = (components, _options, context) => {
+  if (!isObject(components))
+    return [];
+  const refs = /* @__PURE__ */ new Set();
+  collectRefs(context.document.data, refs);
+  const isReferenced = (base) => {
+    for (const ref of refs) {
+      if (ref === base || ref.startsWith(`${base}/`))
+        return true;
+    }
+    return false;
+  };
+  const results = [];
+  for (const type of REUSABLE_COMPONENT_TYPES) {
+    const group = components[type];
+    if (!isObject(group))
+      continue;
+    for (const key of Object.keys(group)) {
+      if (!isReferenced(`#/components/${type}/${key}`)) {
+        results.push({ message: "Potentially unused component has been detected.", path: [...context.path, type, key] });
+      }
     }
-    return results;
+  }
+  return results;
+};
+export {
+  oasUnusedComponent
 };

package/dist/rules/openapi/functions/ref-siblings.d.ts

@@ -1,3 +1,3 @@
-import type { RulesetFunction } from '../../../core/index.js';
+import type { RulesetFunction } from '../../../core/types.js';
 /** Flags objects that mix `$ref` with sibling keys (which are ignored per spec). */
 export declare const refSiblings: RulesetFunction;

package/dist/rules/openapi/functions/ref-siblings.js

@@ -1,13 +1,15 @@
-import { isObject } from './helpers.js';
-/** Flags objects that mix `$ref` with sibling keys (which are ignored per spec). */
-export const refSiblings = (input, _options, context) => {
-    if (!isObject(input) || !('$ref' in input))
-        return [];
-    const results = [];
-    for (const key of Object.keys(input)) {
-        if (key !== '$ref') {
-            results.push({ message: `$ref must not be placed next to "${key}"`, path: [...context.path, key] });
-        }
+import { isObject } from "./helpers.js";
+const refSiblings = (input, _options, context) => {
+  if (!isObject(input) || !("$ref" in input))
+    return [];
+  const results = [];
+  for (const key of Object.keys(input)) {
+    if (key !== "$ref") {
+      results.push({ message: `$ref must not be placed next to "${key}"`, path: [...context.path, key] });
     }
-    return results;
+  }
+  return results;
+};
+export {
+  refSiblings
 };

package/dist/rules/openapi/index.d.ts

@@ -1,4 +1,5 @@
-import { type FunctionRegistry, type ResolvedExtend, type Ruleset, type RulesetDefinition } from '../../core/index.js';
+import { type ResolvedExtend, type Ruleset } from '../../core/index.js';
+import type { FunctionRegistry, RulesetDefinition } from '../../core/types.js';
 export { oasFixers } from './fixers.js';
 export { oas2, oas3, oas3_0, oas3_1, oas3_2, oasFormats } from './formats.js';
 export { oasFunctions } from './functions/index.js';

package/dist/rules/openapi/index.js

@@ -1,127 +1,109 @@
-import { readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { dirname, isAbsolute, resolve as resolvePath } from 'node:path';
-import { createRuleset as createCoreRuleset, } from '../../core/index.js';
-import { builtinFunctions } from '../../functions/index.js';
-import { parseWithPointers } from '../../parsers/index.js';
-import { oasFormats } from './formats.js';
-import { oasFunctions } from './functions/index.js';
-import { oas } from './oas.js';
-export { oasFixers } from './fixers.js';
-export { oas2, oas3, oas3_0, oas3_1, oas3_2, oasFormats } from './formats.js';
-export { oasFunctions } from './functions/index.js';
-export { oas } from './oas.js';
-export { loadOasSchema } from './schemas/index.js';
-/** The built-in `@amritk/lint` functions plus the OpenAPI-specific ones, keyed by name. */
-export const allFunctions = { ...builtinFunctions, ...oasFunctions };
-const require = createRequire(import.meta.url);
-/** The names that resolve to the built-in OpenAPI ruleset (incl. the legacy Spectral alias). */
-const OAS_RULESET_NAMES = new Set(['oas', 'loupe:oas', 'spectral:oas']);
-/** 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 } from "../../core/index.js";
+import { builtinFunctions } from "../../functions/index.js";
+import { parseWithPointers } from "../../parsers/index.js";
+import { oasFormats } from "./formats.js";
+import { oasFunctions } from "./functions/index.js";
+import { oas } from "./oas.js";
+import { oasFixers } from "./fixers.js";
+import { oas2, oas3, oas3_0, oas3_1, oas3_2, oasFormats as oasFormats2 } from "./formats.js";
+import { oasFunctions as oasFunctions2 } from "./functions/index.js";
+import { oas as oas4 } from "./oas.js";
+import { loadOasSchema } from "./schemas/index.js";
+const allFunctions = { ...builtinFunctions, ...oasFunctions };
+const require2 = createRequire(import.meta.url);
+const OAS_RULESET_NAMES = /* @__PURE__ */ new Set(["oas", "loupe:oas", "spectral:oas"]);
 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. Extends the generic
- * file/package resolution with the OpenAPI preset names:
- * - `oas` / `loupe:oas` / `spectral:oas` → the built-in {@link oas} ruleset,
- * - local file paths (relative to `basePath`, or absolute): `.yaml` / `.yml` / `.json` / `.js`,
- * - npm package specifiers (resolved from `basePath`), including subpaths.
- */
-export const resolveOpenApiRuleset = (name, basePath = process.cwd()) => {
-    if (OAS_RULESET_NAMES.has(name))
-        return { definition: oas, basePath };
-    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 resolveOpenApiRuleset = (name, basePath = process.cwd()) => {
+  if (OAS_RULESET_NAMES.has(name))
+    return { definition: oas, basePath };
+  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. The built-in `oas` names carry
- * no custom functions, so they are skipped.
- */
 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') {
-                if (OAS_RULESET_NAMES.has(target))
-                    continue;
-                const resolved = resolveOpenApiRuleset(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);
+  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") {
+        if (OAS_RULESET_NAMES.has(target))
+          continue;
+        const resolved = resolveOpenApiRuleset(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 createOpenApiRuleset = (definition, basePath) => {
+  const resolved = definition ?? { extends: [oas] };
+  let functions = allFunctions;
+  const custom = {};
+  collectCustomFunctions(resolved, basePath ?? process.cwd(), custom, /* @__PURE__ */ new Set());
+  if (Object.keys(custom).length > 0)
+    functions = { ...allFunctions, ...custom };
+  return createCoreRuleset(resolved, {
+    functions,
+    formats: oasFormats,
+    resolve: resolveOpenApiRuleset,
+    ...basePath !== void 0 ? { basePath } : {}
+  });
 };
-/**
- * Builds a runnable {@link Ruleset} for OpenAPI, layering the built-in and
- * OpenAPI functions (plus any custom ones the definition declares), the OpenAPI
- * `formats`, and `extends` resolution that understands the `oas` / `loupe:oas` /
- * `spectral:oas` names. With no definition it defaults to `extends: [oas]`
- * (recommended rules only). Feed the result to `@amritk/lint`'s core
- * `lintWithResult` (with a `$ref` resolver for `resolved: true` rules).
- */
-export const createOpenApiRuleset = (definition, basePath) => {
-    // With no explicit ruleset, behave like `extends: [oas]` so only `recommended`
-    // rules run by default. A user-supplied ruleset is used as-is (its own rules
-    // run regardless of `recommended`).
-    const resolved = definition ?? { extends: [oas] };
-    // 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 = allFunctions;
-    const custom = {};
-    collectCustomFunctions(resolved, basePath ?? process.cwd(), custom, new Set());
-    if (Object.keys(custom).length > 0)
-        functions = { ...allFunctions, ...custom };
-    return createCoreRuleset(resolved, {
-        functions,
-        formats: oasFormats,
-        resolve: resolveOpenApiRuleset,
-        ...(basePath !== undefined ? { basePath } : {}),
-    });
+export {
+  allFunctions,
+  createOpenApiRuleset,
+  loadOasSchema,
+  oas4 as oas,
+  oas2,
+  oas3,
+  oas3_0,
+  oas3_1,
+  oas3_2,
+  oasFixers,
+  oasFormats2 as oasFormats,
+  oasFunctions2 as oasFunctions,
+  resolveOpenApiRuleset
 };

package/dist/rules/openapi/oas.d.ts

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