@amritk/lint 0.4.8 → 0.5.0

package/dist/ruleset-files.js

@@ -0,0 +1,92 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, resolve as resolvePath, sep } from "node:path";
+import { setOwnKey } from "./core/own-key.js";
+import { parseWithPointers } from "./parsers/index.js";
+const require2 = createRequire(import.meta.url);
+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 loadRulesetFile = (file) => {
+  if (/\.(ya?ml|json)$/i.test(file)) {
+    return parseWithPointers(readFileSync(file, "utf8")).data;
+  }
+  const module = require2(file);
+  return module.default ?? module;
+};
+const resolveRulesetFile = (name, basePath, 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, options) => {
+  if (typeof definition !== "object" || definition === null)
+    return;
+  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 = options.resolveExtend(target, basePath);
+        if (resolved)
+          collectCustomFunctions(resolved.definition, resolved.basePath, into, seen, options);
+      } else {
+        collectCustomFunctions(target, basePath, into, seen, options);
+      }
+    }
+  }
+  if (Array.isArray(definition.functions)) {
+    const dir = definition.functionsDir ?? "functions";
+    for (const name of definition.functions) {
+      setOwnKey(into, name, loadFunctionByName(basePath, dir, name, options.restrictTo));
+    }
+  }
+};
+export {
+  assertWithinRoot,
+  collectCustomFunctions,
+  loadFunctionByName,
+  loadRulesetFile,
+  resolveRulesetFile
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/lint",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "description": "A fast, format-agnostic JSON/YAML style-guide linter with JSON Schema and custom rules.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -60,15 +60,19 @@
     "./rules/openapi": {
       "types": "./dist/rules/openapi/index.d.ts",
       "default": "./dist/rules/openapi/index.js"
+    },
+    "./rules/asyncapi": {
+      "types": "./dist/rules/asyncapi/index.d.ts",
+      "default": "./dist/rules/asyncapi/index.js"
     }
   },
   "dependencies": {
-    "@amritk/runtime-validators": "^0.11.0",
-    "@amritk/yaml": "^0.7.1",
+    "@amritk/runtime-validators": "^0.12.0",
+    "@amritk/yaml": "^0.7.2",
     "jsonc-parser": "^3.3.1"
   },
   "devDependencies": {
-    "@amritk/resolve-refs": "^0.7.0",
+    "@amritk/resolve-refs": "^0.7.1",
     "@stoplight/spectral-core": "^1.23.1",
     "@stoplight/spectral-parsers": "^1.0.5",
     "@stoplight/spectral-rulesets": "^1.22.7"