@amritk/lint 0.3.2 → 0.3.3

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
 };