@amritk/lint 0.3.2 → 0.3.3

package/dist/functions/defined.js

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

package/dist/functions/enumeration.js

@@ -1,27 +1,17 @@
-/**
- * True for the primitive kinds Spectral's input schema accepts
- * (`string`, `number`, `null`, `boolean`). Objects and arrays are excluded so
- * they cannot slip through the reference-equality `includes` check below and be
- * flagged against a list they could never be `===` to.
- */
-const isPrimitive = (value) => value === null || (typeof value !== 'object' && typeof value !== 'function');
-/** Flags a value that is not one of the allowed `values`. */
-export const enumeration = (input, options) => {
-    const values = options?.values;
-    // Without a valid list of allowed values there is nothing to compare against.
-    // Spectral requires `values` in its option schema and no-ops when it is
-    // missing, so skip rather than flag everything against an empty allow-list.
-    if (!Array.isArray(values))
-        return [];
-    // Spectral's input schema only lets primitives reach this function. `includes`
-    // uses reference equality, so a non-primitive would always be reported as
-    // "not allowed"; match Spectral by skipping objects and arrays entirely.
-    if (!isPrimitive(input))
-        return [];
-    if (!values.includes(input)) {
-        return [
-            { message: `The value must be one of the allowed values: ${values.map((v) => JSON.stringify(v)).join(', ')}` },
-        ];
-    }
+const isPrimitive = (value) => value === null || typeof value !== "object" && typeof value !== "function";
+const enumeration = (input, options) => {
+  const values = options?.values;
+  if (!Array.isArray(values))
     return [];
+  if (!isPrimitive(input))
+    return [];
+  if (!values.includes(input)) {
+    return [
+      { message: `The value must be one of the allowed values: ${values.map((v) => JSON.stringify(v)).join(", ")}` }
+    ];
+  }
+  return [];
+};
+export {
+  enumeration
 };

package/dist/functions/falsy.js

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

package/dist/functions/index.js

@@ -1,45 +1,61 @@
-import { alphabetical } from './alphabetical.js';
-import { casing } from './casing.js';
-import { defined } from './defined.js';
-import { enumeration } from './enumeration.js';
-import { falsy } from './falsy.js';
-import { length } from './length.js';
-import { or } from './or.js';
-import { pattern } from './pattern.js';
-import { schema } from './schema.js';
-import { truthy } from './truthy.js';
-import { typedEnum } from './typed-enum.js';
-import { undefinedFn } from './undefined.js';
-import { unreferencedReusableObject } from './unreferenced-reusable-object.js';
-import { xor } from './xor.js';
-export { alphabetical } from './alphabetical.js';
-export { casing } from './casing.js';
-export { defined } from './defined.js';
-export { enumeration } from './enumeration.js';
-export { falsy } from './falsy.js';
-export { length } from './length.js';
-export { or } from './or.js';
-export { pattern } from './pattern.js';
-export { schema } from './schema.js';
-export { truthy } from './truthy.js';
-export { typedEnum } from './typed-enum.js';
-export { undefinedFn } from './undefined.js';
-export { unreferencedReusableObject } from './unreferenced-reusable-object.js';
-export { xor } from './xor.js';
-/** All built-in functions, keyed by their Linter-compatible names. */
-export const builtinFunctions = {
-    alphabetical: alphabetical,
-    casing: casing,
-    defined,
-    enumeration: enumeration,
-    falsy,
-    length: length,
-    or: or,
-    pattern: pattern,
-    schema: schema,
-    truthy,
-    undefined: undefinedFn,
-    unreferencedReusableObject: unreferencedReusableObject,
-    xor: xor,
-    typedEnum: typedEnum,
+import { alphabetical } from "./alphabetical.js";
+import { casing } from "./casing.js";
+import { defined } from "./defined.js";
+import { enumeration } from "./enumeration.js";
+import { falsy } from "./falsy.js";
+import { length } from "./length.js";
+import { or } from "./or.js";
+import { pattern } from "./pattern.js";
+import { schema } from "./schema.js";
+import { truthy } from "./truthy.js";
+import { typedEnum } from "./typed-enum.js";
+import { undefinedFn } from "./undefined.js";
+import { unreferencedReusableObject } from "./unreferenced-reusable-object.js";
+import { xor } from "./xor.js";
+import { alphabetical as alphabetical2 } from "./alphabetical.js";
+import { casing as casing2 } from "./casing.js";
+import { defined as defined2 } from "./defined.js";
+import { enumeration as enumeration2 } from "./enumeration.js";
+import { falsy as falsy2 } from "./falsy.js";
+import { length as length2 } from "./length.js";
+import { or as or2 } from "./or.js";
+import { pattern as pattern2 } from "./pattern.js";
+import { schema as schema2 } from "./schema.js";
+import { truthy as truthy2 } from "./truthy.js";
+import { typedEnum as typedEnum2 } from "./typed-enum.js";
+import { undefinedFn as undefinedFn2 } from "./undefined.js";
+import { unreferencedReusableObject as unreferencedReusableObject2 } from "./unreferenced-reusable-object.js";
+import { xor as xor2 } from "./xor.js";
+const builtinFunctions = {
+  alphabetical,
+  casing,
+  defined,
+  enumeration,
+  falsy,
+  length,
+  or,
+  pattern,
+  schema,
+  truthy,
+  undefined: undefinedFn,
+  unreferencedReusableObject,
+  xor,
+  typedEnum
+};
+export {
+  alphabetical2 as alphabetical,
+  builtinFunctions,
+  casing2 as casing,
+  defined2 as defined,
+  enumeration2 as enumeration,
+  falsy2 as falsy,
+  length2 as length,
+  or2 as or,
+  pattern2 as pattern,
+  schema2 as schema,
+  truthy2 as truthy,
+  typedEnum2 as typedEnum,
+  undefinedFn2 as undefinedFn,
+  unreferencedReusableObject2 as unreferencedReusableObject,
+  xor2 as xor
 };

package/dist/functions/length.js

@@ -1,35 +1,25 @@
-/**
- * Returns the comparable size of a value: string/array length, object key count,
- * or the number itself. `undefined` for anything else (so the rule is skipped).
- */
 const measure = (input) => {
-    if (typeof input === 'string' || Array.isArray(input))
-        return input.length;
-    if (typeof input === 'object' && input !== null)
-        return Object.keys(input).length;
-    if (typeof input === 'number')
-        return input;
-    return undefined;
+  if (typeof input === "string" || Array.isArray(input))
+    return input.length;
+  if (typeof input === "object" && input !== null)
+    return Object.keys(input).length;
+  if (typeof input === "number")
+    return input;
+  return void 0;
 };
-/**
- * Flags a value whose size falls outside the `min`/`max` bounds.
- *
- * With neither `min` nor `max` supplied this is a no-op on every node. That
- * matches Spectral, which requires at least one bound in its option schema and
- * simply produces no results once the options load without them. We also ignore
- * a `min`/`max` that is not a number so a stray string like "3" cannot slip into
- * the `<`/`>` comparison and be coerced into a misleading result.
- */
-export const length = (input, options) => {
-    const size = measure(input);
-    if (size === undefined)
-        return [];
-    const results = [];
-    if (typeof options?.min === 'number' && size < options.min) {
-        results.push({ message: `The value must not be shorter than ${options.min}` });
-    }
-    if (typeof options?.max === 'number' && size > options.max) {
-        results.push({ message: `The value must not be longer than ${options.max}` });
-    }
-    return results;
+const length = (input, options) => {
+  const size = measure(input);
+  if (size === void 0)
+    return [];
+  const results = [];
+  if (typeof options?.min === "number" && size < options.min) {
+    results.push({ message: `The value must not be shorter than ${options.min}` });
+  }
+  if (typeof options?.max === "number" && size > options.max) {
+    results.push({ message: `The value must not be longer than ${options.max}` });
+  }
+  return results;
+};
+export {
+  length
 };

package/dist/functions/or.js

@@ -1,25 +1,19 @@
-/**
- * Flags an object when none of the listed `properties` is defined on it. Where
- * {@link xor} requires exactly one, `or` requires at least one — it stays quiet
- * as soon as a single listed property is present.
- */
-export const or = (input, options) => {
-    if (typeof input !== 'object' || input === null)
-        return [];
-    const properties = options?.properties;
-    // Spectral validates that at least two properties are supplied and no-ops when
-    // that is not the case, so we skip in silence rather than flag every node.
-    if (!Array.isArray(properties) || properties.length < 2)
-        return [];
-    const present = properties.filter((property) => property in input);
-    if (present.length > 0)
-        return [];
-    // Match Spectral's message: a long list is abbreviated to the first three
-    // properties plus a count of the rest so the finding stays readable.
-    if (properties.length > 4) {
-        const shortProps = properties.slice(0, 3);
-        const count = `${properties.length - 3} other properties must be defined`;
-        return [{ message: `At least one of "${shortProps.join('" or "')}" or ${count}` }];
-    }
-    return [{ message: `At least one of "${properties.join('" or "')}" must be defined` }];
+const or = (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 > 0)
+    return [];
+  if (properties.length > 4) {
+    const shortProps = properties.slice(0, 3);
+    const count = `${properties.length - 3} other properties must be defined`;
+    return [{ message: `At least one of "${shortProps.join('" or "')}" or ${count}` }];
+  }
+  return [{ message: `At least one of "${properties.join('" or "')}" must be defined` }];
+};
+export {
+  or
 };

package/dist/functions/pattern.js

@@ -1,53 +1,43 @@
-// Compiling a RegExp is not free, and rules run this function once per matched
-// node, so we memoize by the raw pattern string (which carries its own flags in
-// the `/re/flags` form). A failed compile is cached as its `Error` so a bad
-// pattern is reported without being re-thrown on every node. Mirrors Spectral's
-// own module-level cache.
-const cache = new Map();
-/** Parses a `/pattern/flags` string (or a bare pattern) into a RegExp, or the compile error. */
-const toRegExp = (pattern) => {
-    const cached = cache.get(pattern);
-    if (cached !== undefined) {
-        // A cached RegExp carrying the `g`/`y` flag keeps `lastIndex` between calls,
-        // which would make `.test` skip characters on the next node. Reset it so a
-        // reused pattern behaves the same as a freshly compiled one.
-        if (cached instanceof RegExp)
-            cached.lastIndex = 0;
-        return cached;
-    }
-    let compiled;
-    try {
-        const match = /^\/(.+)\/([a-z]*)$/s.exec(pattern);
-        compiled = match ? new RegExp(match[1], match[2]) : new RegExp(pattern);
-    }
-    catch (error) {
-        compiled = error instanceof Error ? error : new Error(String(error));
-    }
-    cache.set(pattern, compiled);
-    return compiled;
+const cache = /* @__PURE__ */ new Map();
+const toRegExp = (pattern2) => {
+  const cached = cache.get(pattern2);
+  if (cached !== void 0) {
+    if (cached instanceof RegExp)
+      cached.lastIndex = 0;
+    return cached;
+  }
+  let compiled;
+  try {
+    const match = /^\/(.+)\/([a-z]*)$/s.exec(pattern2);
+    compiled = match ? new RegExp(match[1], match[2]) : new RegExp(pattern2);
+  } catch (error) {
+    compiled = error instanceof Error ? error : new Error(String(error));
+  }
+  cache.set(pattern2, compiled);
+  return compiled;
 };
-/** Flags a string that fails `match` or satisfies `notMatch`. */
-export const pattern = (input, options) => {
-    if (typeof input !== 'string')
-        return [];
-    const results = [];
-    if (options?.match !== undefined) {
-        const re = toRegExp(options.match);
-        if (re instanceof Error) {
-            results.push({ message: `The "match" option is not a valid regular expression: ${re.message}` });
-        }
-        else if (!re.test(input)) {
-            results.push({ message: `The value must match the pattern "${options.match}"` });
-        }
+const pattern = (input, options) => {
+  if (typeof input !== "string")
+    return [];
+  const results = [];
+  if (options?.match !== void 0) {
+    const re = toRegExp(options.match);
+    if (re instanceof Error) {
+      results.push({ message: `The "match" option is not a valid regular expression: ${re.message}` });
+    } else if (!re.test(input)) {
+      results.push({ message: `The value must match the pattern "${options.match}"` });
     }
-    if (options?.notMatch !== undefined) {
-        const re = toRegExp(options.notMatch);
-        if (re instanceof Error) {
-            results.push({ message: `The "notMatch" option is not a valid regular expression: ${re.message}` });
-        }
-        else if (re.test(input)) {
-            results.push({ message: `The value must not match the pattern "${options.notMatch}"` });
-        }
+  }
+  if (options?.notMatch !== void 0) {
+    const re = toRegExp(options.notMatch);
+    if (re instanceof Error) {
+      results.push({ message: `The "notMatch" option is not a valid regular expression: ${re.message}` });
+    } else if (re.test(input)) {
+      results.push({ message: `The value must not match the pattern "${options.notMatch}"` });
     }
-    return results;
+  }
+  return results;
+};
+export {
+  pattern
 };

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