@amritk/lint 0.4.7 → 0.4.8

package/dist/core/own-key.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Own-property reads and writes for maps keyed by names the ruleset or the
+ * linted document supplies.
+ *
+ * Those names are author-chosen, so `constructor`, `toString` and `__proto__`
+ * are all names someone may legitimately use — and a bare index answers them
+ * from `Object.prototype` while a bare assignment on `__proto__` sets the map's
+ * prototype instead of adding a key. Neither is ever what the caller meant.
+ *
+ * `@amritk/helpers` carries the same pair, but `@amritk/lint` depends on
+ * nothing beyond `@amritk/runtime-validators` and `@amritk/yaml` by design (see
+ * `.claude/architecture.md`), so it keeps its own. One copy inside the package,
+ * not one per call site.
+ */
+/** The value at `key`, or `undefined` when the map does not own that name. */
+export declare const ownKey: <T>(source: Readonly<Record<string, T>>, key: string) => T | undefined;
+/** Assigns `value` under `key` as an own data property, `__proto__` included. */
+export declare const setOwnKey: <T>(target: Record<string, T>, key: string, value: NoInfer<T>) => void;

package/dist/core/own-key.js

@@ -0,0 +1,12 @@
+const ownKey = (source, key) => Object.hasOwn(source, key) ? source[key] : void 0;
+const setOwnKey = (target, key, value) => {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });
+  } else {
+    target[key] = value;
+  }
+};
+export {
+  ownKey,
+  setOwnKey
+};

package/dist/core/ruleset.js

@@ -1,6 +1,7 @@
 import { DiagnosticSeverity } from "../parsers/index.js";
 import { matchesGlob } from "./glob.js";
 import { compileQuery } from "./jsonpath.js";
+import { ownKey, setOwnKey } from "./own-key.js";
 const SEVERITY_NAMES = {
   error: DiagnosticSeverity.Error,
   warn: DiagnosticSeverity.Warning,
@@ -13,7 +14,7 @@ const parseSeverity = (value) => {
     return { severity: DiagnosticSeverity.Warning, enabled: true };
   if (typeof value === "number")
     return { severity: value, enabled: true };
-  const mapped = SEVERITY_NAMES[value];
+  const mapped = ownKey(SEVERITY_NAMES, value);
   if (mapped === "off")
     return { severity: DiagnosticSeverity.Warning, enabled: false };
   if (mapped === void 0)
@@ -65,19 +66,19 @@ const applyEntry = (rules, name, entry, throwOnMissing = false) => {
   rules.set(name, normalizeRule(name, entry, "all"));
 };
 const registerAlias = (ctx, declaringAliases, name, ruleName) => {
-  const alias = declaringAliases[name];
+  const alias = ownKey(declaringAliases, name);
   if (!alias)
     throw new Error(`Rule "${ruleName}" references undefined alias "#${name}"`);
-  const existing = ctx.aliases[name];
+  const existing = ownKey(ctx.aliases, name);
   if (existing === void 0 || existing === alias) {
-    ctx.aliases[name] = alias;
+    setOwnKey(ctx.aliases, name, alias);
     return name;
   }
   for (let n = 0; ; n++) {
     const key = `${name}__${n}`;
-    const at = ctx.aliases[key];
+    const at = ownKey(ctx.aliases, key);
     if (at === void 0 || at === alias) {
-      ctx.aliases[key] = alias;
+      setOwnKey(ctx.aliases, key, alias);
       return key;
     }
   }
@@ -178,7 +179,7 @@ const createRuleset = (definition, options = {}) => {
     }
   }
   const resolveAlias = (name, documentFormats) => {
-    const alias = aliases[name];
+    const alias = ownKey(aliases, name);
     if (!alias)
       return [];
     if (Array.isArray(alias))
@@ -199,7 +200,11 @@ const createRuleset = (definition, options = {}) => {
     overrides,
     parserOptions,
     enabledRules: rules.filter((rule) => rule.enabled),
-    getFunction: (name) => functions[name],
+    // `Object.hasOwn`, not a bare index: `then.function` is ruleset input, so
+    // `"toString"` otherwise resolved to `Function.prototype.toString` and ran
+    // as a rule function instead of being reported as unknown — its string
+    // return value then read as an iterable of per-character diagnostics.
+    getFunction: (name) => ownKey(functions, name),
     rulesForSource: (source) => {
       if (!source || !hasOverrides)
         return rules;

package/dist/fix/apply.js

@@ -1,3 +1,4 @@
+import { ownKey } from "../core/own-key.js";
 import { applyEditOpsWithChanges } from "../parsers/index.js";
 const STRUCTURAL_ARRAY_OPS = /* @__PURE__ */ new Set(["removeItems", "reorderArray", "insertItem"]);
 const isStructuralArrayOp = (op) => STRUCTURAL_ARRAY_OPS.has(op.op);
@@ -12,7 +13,8 @@ const applyFixes = (input, format, data, diagnostics, fixers, options = {}) => {
   const safeOnly = options.safeOnly !== false;
   const candidates = [];
   for (const diagnostic of diagnostics) {
-    const fixer = fixers[String(diagnostic.code)];
+    const code = String(diagnostic.code);
+    const fixer = ownKey(fixers, code);
     if (!fixer)
       continue;
     if (safeOnly && fixer.safe === false)

package/dist/functions/alphabetical.d.ts

@@ -4,5 +4,19 @@ export type IAlphabeticalOptions = {
     /** Compare objects by this property instead of the value itself. */
     keyedBy?: string;
 };
+/**
+ * Exported so the `openapi-tags-alphabetical` fixer sorts by the very function
+ * the rule judges with. A second comparator that merely looked equivalent
+ * drifted: it missed the numeric-string cases below, so `["10", "2"]` was
+ * flagged by the rule and left untouched by the fixer, forever.
+ *
+ * Deliberately **not** a total order. Numeric-vs-textual is decided per pair,
+ * which is what keeps both `["2", "10"]` and `["0x10", "9"]` reading as
+ * ordered — two requirements no single total order can satisfy, since
+ * lexicographically `"1e2"` falls between `"10"` and `"2"` while numerically
+ * `"2"` precedes `"10"`. A caller that feeds this to `Array.prototype.sort`
+ * therefore has to check the result rather than trust it; see the tags fixer.
+ */
+export declare const compareAlphabetically: (a: unknown, b: unknown) => number;
 /** Flags array items or object keys that are not in ascending (optionally `keyedBy`) order. */
 export declare const alphabetical: RulesetFunction<unknown, IAlphabeticalOptions>;

package/dist/functions/alphabetical.js

@@ -3,7 +3,7 @@ const isStringOrNumber = (value) => typeof value === "string" || typeof value ==
 const isIntegerLike = (value) => typeof value === "string" && /^(?:0|[1-9]\d*)$/.test(value);
 const DECIMAL_NUMBER = /^-?\d+(?:\.\d+)?$/;
 const isNumeric = (value) => typeof value === "number" || typeof value === "string" && DECIMAL_NUMBER.test(value);
-const compare = (a, b) => {
+const compareAlphabetically = (a, b) => {
   if (isIntegerLike(a) && isIntegerLike(b))
     return Math.sign(Number(a) - Number(b));
   if (isNumeric(a) && isNumeric(b)) {
@@ -34,7 +34,7 @@ const alphabetical = (input, options, context) => {
   }
   const results = [];
   for (let i = 0; i < items.length - 1; i++) {
-    if (compare(items[i], items[i + 1]) > 0) {
+    if (compareAlphabetically(items[i], items[i + 1]) > 0) {
       const path = isArray ? [...context.path, i + 1] : [...context.path, rawItems[i + 1]];
       results.push({ message: "The items must be in alphabetical order", path });
     }
@@ -42,5 +42,6 @@ const alphabetical = (input, options, context) => {
   return results;
 };
 export {
-  alphabetical
+  alphabetical,
+  compareAlphabetically
 };

package/dist/index.js

@@ -172,7 +172,7 @@ const fixDocument = async (input, options = {}) => {
     }
   }
   const remaining = (await runLint(current, ruleset, lintOptions)).diagnostics;
-  return { output: current, fixed: applied.length > 0, remaining, applied, converged, passes };
+  return { output: current, fixed: current !== input, remaining, applied, converged, passes };
 };
 export {
   FIX_PLUGIN_NAME2 as FIX_PLUGIN_NAME,

package/dist/rules/openapi/fixers.js

@@ -1,3 +1,4 @@
+import { compareAlphabetically } from "../../functions/alphabetical.js";
 const getAtPath = (data, path) => {
   let current = data;
   for (const segment of path) {
@@ -73,11 +74,6 @@ const duplicatedEnum = {
     return { op: "removeItems", path: diagnostic.path, indices: duplicates };
   }
 };
-const compareAlphabetical = (a, b) => {
-  if (typeof a === "number" && typeof b === "number")
-    return a - b;
-  return String(a).localeCompare(String(b));
-};
 const tagsAlphabetical = {
   safe: true,
   fix: ({ diagnostic, data }) => {
@@ -86,9 +82,14 @@ const tagsAlphabetical = {
     if (!Array.isArray(array))
       return void 0;
     const nameOf = (item) => item != null && typeof item === "object" ? item["name"] : item;
-    const order = array.map((_, index) => index).sort((a, b) => compareAlphabetical(nameOf(array[a]), nameOf(array[b])));
+    const order = array.map((_, index) => index).sort((a, b) => compareAlphabetically(nameOf(array[a]), nameOf(array[b])));
     if (order.every((value, index) => value === index))
       return void 0;
+    const sorted = order.map((index) => nameOf(array[index]));
+    for (let i = 0; i < sorted.length - 1; i++) {
+      if (compareAlphabetically(sorted[i], sorted[i + 1]) > 0)
+        return void 0;
+    }
     return { op: "reorderArray", path: arrayPath, order };
   }
 };

package/dist/rules/openapi/functions/oas-path-param.js

@@ -1,3 +1,4 @@
+import { setOwnKey } from "../../../core/own-key.js";
 import { isObject, OPERATION_METHODS } from "./helpers.js";
 const PATH_TEMPLATE = /(\{;?\??[a-zA-Z0-9_-]+\*?\})/g;
 const namedPathParam = (param) => param["in"] === "path" && typeof param["name"] === "string" ? param["name"] : void 0;
@@ -11,7 +12,7 @@ const recordPathParam = (param, definitionPath, seen, results) => {
       path: definitionPath
     });
   }
-  if (name in seen) {
+  if (Object.hasOwn(seen, name)) {
     results.push({ message: `Path parameter "${name}" must not be defined multiple times`, path: definitionPath });
     return void 0;
   }
@@ -44,7 +45,7 @@ const oasPathParam = (paths, _options, context) => {
         const definitionPath = [...context.path, path, "parameters", index];
         const name = recordPathParam(param, definitionPath, topParams, results);
         if (name !== void 0)
-          topParams[name] = definitionPath;
+          setOwnKey(topParams, name, definitionPath);
       });
     }
     for (const [method, operation] of Object.entries(item)) {
@@ -59,7 +60,7 @@ const oasPathParam = (paths, _options, context) => {
           const definitionPath = [...operationPath, "parameters", index];
           const name = recordPathParam(param, definitionPath, operationParams, results);
           if (name !== void 0)
-            operationParams[name] = definitionPath;
+            setOwnKey(operationParams, name, definitionPath);
         });
       }
       const defined = { ...topParams, ...operationParams };
@@ -69,7 +70,7 @@ const oasPathParam = (paths, _options, context) => {
         }
       }
       for (const name of templates) {
-        if (!(name in defined)) {
+        if (!Object.hasOwn(defined, name)) {
           results.push({
             message: `Operation must define path parameter "{${name}}" as expected by path "${path}"`,
             path: operationPath

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/lint",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "description": "A fast, format-agnostic JSON/YAML style-guide linter with JSON Schema and custom rules.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -63,14 +63,14 @@
     }
   },
   "dependencies": {
-    "@amritk/runtime-validators": "^0.10.1",
+    "@amritk/runtime-validators": "^0.11.0",
     "@amritk/yaml": "^0.7.1",
     "jsonc-parser": "^3.3.1"
   },
   "devDependencies": {
-    "@amritk/resolve-refs": "^0.5.1",
+    "@amritk/resolve-refs": "^0.7.0",
     "@stoplight/spectral-core": "^1.23.1",
     "@stoplight/spectral-parsers": "^1.0.5",
-    "@stoplight/spectral-rulesets": "^1.22.6"
+    "@stoplight/spectral-rulesets": "^1.22.7"
   }
 }