@amritk/lint 0.3.2 → 0.4.0

package/dist/functions/schema.js

@@ -1,129 +1,103 @@
-import { validate as buildValidator } from '@amritk/runtime-validators';
-// The rule's `options.schema` is a stable object, so cache the prepared
-// validator by identity. `@amritk/runtime-validators` interprets the schema at
-// runtime (no `new Function`), keeping this eval-free and dependency-light.
-const validators = new WeakMap();
-const getValidator = (schema) => {
-    let validator = validators.get(schema);
-    if (!validator) {
-        // The `schema` built-in historically enforced string formats (ajv
-        // `validateFormats: true`); keep that by opting into all formats here.
-        validator = buildValidator(schema, { formats: 'all' });
-        validators.set(schema, validator);
-    }
-    return validator;
+import { validate as buildValidator } from "@amritk/runtime-validators";
+const validators = /* @__PURE__ */ new WeakMap();
+const getValidator = (schema2) => {
+  let validator = validators.get(schema2);
+  if (!validator) {
+    validator = buildValidator(schema2, { formats: "all" });
+    validators.set(schema2, validator);
+  }
+  return validator;
 };
-const KNOWN_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'null', 'object', 'array']);
-// Keywords whose value is itself a schema, a list of schemas, or a map of
-// schemas. We recurse through them to reach every `type` a schema declares.
-const SCHEMA_VALUE_KEYS = ['additionalProperties', 'not', 'if', 'then', 'else', 'propertyNames', 'contains'];
-const SCHEMA_ITEMS_KEYS = ['items', 'additionalItems'];
-const SCHEMA_LIST_KEYS = ['allOf', 'anyOf', 'oneOf'];
-const SCHEMA_MAP_KEYS = ['properties', 'patternProperties', 'definitions', '$defs', 'dependencies'];
-/**
- * Walks a schema looking for a `type` keyword whose value is not a JSON Schema
- * type. `@amritk/runtime-validators` treats an unknown `type` as "always
- * matches" (so it never rejects data it does not model), which means a typo like
- * `type: "Pascal"` would silently disable the rule. Finding it up front lets us
- * report it instead. Returns the offending type, or `undefined` when the schema
- * only uses known types.
- */
+const KNOWN_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null", "object", "array"]);
+const SCHEMA_VALUE_KEYS = ["additionalProperties", "not", "if", "then", "else", "propertyNames", "contains"];
+const SCHEMA_ITEMS_KEYS = ["items", "additionalItems"];
+const SCHEMA_LIST_KEYS = ["allOf", "anyOf", "oneOf"];
+const SCHEMA_MAP_KEYS = ["properties", "patternProperties", "definitions", "$defs", "dependencies"];
 const findInvalidType = (node) => {
-    if (Array.isArray(node) || typeof node !== 'object' || node === null)
-        return undefined;
-    const schema = node;
-    const declared = schema['type'];
-    if (declared !== undefined) {
-        const types = Array.isArray(declared) ? declared : [declared];
-        for (const type of types) {
-            if (typeof type !== 'string' || !KNOWN_TYPES.has(type)) {
-                return typeof type === 'string' ? type : String(type);
-            }
-        }
-    }
-    for (const key of SCHEMA_VALUE_KEYS) {
-        const found = findInvalidType(schema[key]);
-        if (found !== undefined)
-            return found;
+  if (Array.isArray(node) || typeof node !== "object" || node === null)
+    return void 0;
+  const schema2 = node;
+  const declared = schema2["type"];
+  if (declared !== void 0) {
+    const types = Array.isArray(declared) ? declared : [declared];
+    for (const type of types) {
+      if (typeof type !== "string" || !KNOWN_TYPES.has(type)) {
+        return typeof type === "string" ? type : String(type);
+      }
     }
-    for (const key of SCHEMA_ITEMS_KEYS) {
-        const value = schema[key];
-        const list = Array.isArray(value) ? value : [value];
-        for (const item of list) {
-            const found = findInvalidType(item);
-            if (found !== undefined)
-                return found;
-        }
+  }
+  for (const key of SCHEMA_VALUE_KEYS) {
+    const found = findInvalidType(schema2[key]);
+    if (found !== void 0)
+      return found;
+  }
+  for (const key of SCHEMA_ITEMS_KEYS) {
+    const value = schema2[key];
+    const list = Array.isArray(value) ? value : [value];
+    for (const item of list) {
+      const found = findInvalidType(item);
+      if (found !== void 0)
+        return found;
     }
-    for (const key of SCHEMA_LIST_KEYS) {
-        const value = schema[key];
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                const found = findInvalidType(item);
-                if (found !== undefined)
-                    return found;
-            }
-        }
+  }
+  for (const key of SCHEMA_LIST_KEYS) {
+    const value = schema2[key];
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const found = findInvalidType(item);
+        if (found !== void 0)
+          return found;
+      }
     }
-    for (const key of SCHEMA_MAP_KEYS) {
-        const value = schema[key];
-        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-            for (const item of Object.values(value)) {
-                const found = findInvalidType(item);
-                if (found !== undefined)
-                    return found;
-            }
-        }
+  }
+  for (const key of SCHEMA_MAP_KEYS) {
+    const value = schema2[key];
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      for (const item of Object.values(value)) {
+        const found = findInvalidType(item);
+        if (found !== void 0)
+          return found;
+      }
     }
-    return undefined;
+  }
+  return void 0;
 };
-const pointerToPath = (pointer) => pointer
-    .split('/')
-    .slice(1)
-    .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'))
-    .map((segment) => (/^\d+$/.test(segment) ? Number(segment) : segment));
+const pointerToPath = (pointer) => pointer.split("/").slice(1).map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~")).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
 const formatError = (error) => {
-    const location = error.path || 'value';
-    return `${location} ${error.message}`.trim();
+  const location = error.path || "value";
+  return `${location} ${error.message}`.trim();
 };
-/** Validates a value against a JSON Schema supplied in the rule's options. */
-export const schema = (input, options, context) => {
-    if (!options?.schema)
-        return [];
-    // A malformed schema would otherwise validate everything and silently disable
-    // the rule. Surface it as a finding, the way Spectral reports schema compile
-    // errors as results, so the ruleset author notices the mistake.
-    const invalidType = findInvalidType(options.schema);
-    if (invalidType !== undefined) {
-        return [
-            {
-                message: `Invalid schema: unknown type "${invalidType}". Valid types are: ${[...KNOWN_TYPES].join(', ')}`,
-                path: [...context.path],
-            },
-        ];
-    }
-    let result;
-    try {
-        result = getValidator(options.schema)(input);
-    }
-    catch (error) {
-        // Preparing or running the validator can throw on a schema shape we cannot
-        // interpret. Report it rather than letting it bubble up and crash the run.
-        return [
-            {
-                message: `Invalid schema: ${error instanceof Error ? error.message : String(error)}`,
-                path: [...context.path],
-            },
-        ];
-    }
-    if (result === true)
-        return [];
-    // Spectral's ajv defaults to `allErrors: false`, reporting only the first
-    // failure. Honor the same default and only expand to the full list when the
-    // caller opts in.
-    const errors = options.allErrors ? result.errors : result.errors.slice(0, 1);
-    return errors.map((error) => ({
-        message: formatError(error),
-        path: [...context.path, ...pointerToPath(error.path)],
-    }));
+const schema = (input, options, context) => {
+  if (!options?.schema)
+    return [];
+  const invalidType = findInvalidType(options.schema);
+  if (invalidType !== void 0) {
+    return [
+      {
+        message: `Invalid schema: unknown type "${invalidType}". Valid types are: ${[...KNOWN_TYPES].join(", ")}`,
+        path: [...context.path]
+      }
+    ];
+  }
+  let result;
+  try {
+    result = getValidator(options.schema)(input);
+  } catch (error) {
+    return [
+      {
+        message: `Invalid schema: ${error instanceof Error ? error.message : String(error)}`,
+        path: [...context.path]
+      }
+    ];
+  }
+  if (result === true)
+    return [];
+  const errors = options.allErrors ? result.errors : result.errors.slice(0, 1);
+  return errors.map((error) => ({
+    message: formatError(error),
+    path: [...context.path, ...pointerToPath(error.path)]
+  }));
+};
+export {
+  schema
 };

package/dist/functions/truthy.d.ts

@@ -1,3 +1,3 @@
-import type { RulesetFunction } from '../core/index.js';
+import type { RulesetFunction } from '../core/types.js';
 /** Flags a value that is not truthy. */
 export declare const truthy: RulesetFunction;

package/dist/functions/truthy.js

@@ -1,6 +1,8 @@
-/** Flags a value that is not truthy. */
-export const truthy = (input) => {
-    if (!input)
-        return [{ message: 'The value must be truthy' }];
-    return [];
+const truthy = (input) => {
+  if (!input)
+    return [{ message: "The value must be truthy" }];
+  return [];
+};
+export {
+  truthy
 };

package/dist/functions/typed-enum.d.ts

@@ -1,3 +1,3 @@
-import type { RulesetFunction } from '../core/index.js';
+import type { RulesetFunction } from '../core/types.js';
 /** Validates that each `enum` entry matches the schema's declared `type`. */
 export declare const typedEnum: RulesetFunction<Record<string, unknown>, never>;

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.d.ts

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../core/index.js';
+import type { RulesetFunction } from '../core/types.js';
 /**
  * Flags a value that is defined. Exported as `undefinedFn` because `undefined`
  * is a reserved identifier; it is registered under the name `undefined`.

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.d.ts

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../core/index.js';
+import type { RulesetFunction } from '../core/types.js';
 /** Options for {@link unreferencedReusableObject}. */
 export type IUnreferencedReusableObjectOptions = {
     /** JSON pointer to the map of reusable objects, e.g. "#/components/schemas". */

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.d.ts

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../core/index.js';
+import type { RulesetFunction } from '../core/types.js';
 /** Options for {@link xor}. */
 export type IXorOptions = {
     properties: string[];

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.d.ts

@@ -1,8 +1,9 @@
-import { type IDiagnostic, type IDocumentOptions, type LintPlugin, type LintResolver, type ResolvedExtend, type Ruleset, type RulesetDefinition } from './core/index.js';
+import { type IDocumentOptions, type LintPlugin, type LintResolver, type ResolvedExtend, type Ruleset } from './core/index.js';
+import type { IDiagnostic, RulesetDefinition } from './core/types.js';
 import { type AppliedFix, type FixerRegistry } from './fix/index.js';
-export * from './core/index.js';
-export * from './fix/index.js';
-export * from './functions/index.js';
+export { type AliasDefinition, type CompiledPath, compileQuery, createDocument, createLinter, type Document, detectFormats, type ExtendModifier, type ExtendResolver, type Format, globToRegExp, type IDocumentOptions, type IQueryMatch, type IRulesetProblem, type IRunOptions, type Linter, type LintOptions, type LintPlugin, type LintPluginContext, type LintPluginResult, type LintResolver, type LintResolverResult, type LintResult, lint, lintWithResult, matchesGlob, type PluginRunResult, pointerToPath, query, queryCompiled, queryMany, type ResolvedExtend, type Ruleset, type RulesetOptions, resolveSourceOrigin, resolveSourceOriginFromMap, resolveSourcePath, runPlugins, validateRuleset, } from './core/index.js';
+export { type AppliedFix, type ApplyFixesOptions, applyFixes, createFixPlugin, type EditOp, FIX_PLUGIN_NAME, type FixContext, type Fixer, type FixerRegistry, type FixPluginData, type FixResult, type ParserFormat, } from './fix/index.js';
+export { alphabetical, builtinFunctions, type CasingType, casing, defined, enumeration, falsy, type IAlphabeticalOptions, type ICasingOptions, type IOrOptions, type ISchemaOptions, type IUnreferencedReusableObjectOptions, type IXorOptions, length, or, pattern, schema, truthy, typedEnum, undefinedFn, unreferencedReusableObject, xor, } from './functions/index.js';
 export { detectFormat, parseWithPointers } from './parsers/index.js';
 /**
  * Resolves an `extends` reference to a ruleset definition. Supports:
@@ -53,6 +54,18 @@ export type ILintResult = {
  * 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.
+ *
+ * @example
+ * ```ts
+ * const ruleset = {
+ *   rules: {
+ *     'require-name': { given: '$', severity: 'error', then: { field: 'name', function: 'truthy' } },
+ *   },
+ * }
+ * const findings = await lintDocument('version: 1\n', { ruleset, source: 'service.yaml' })
+ * // findings[].range is ZERO-based; add 1 to line/character to print file:line:col.
+ * // findings[].severity is numeric (0 error, 1 warn, 2 info, 3 hint).
+ * ```
  */
 export declare const lintDocument: (input: string, options?: ILintOptions) => Promise<IDiagnostic[]>;
 /**