@amritk/lint 0.3.2 → 0.4.0

package/dist/functions/casing.js

@@ -1,52 +1,46 @@
 const PATTERNS = {
-    flat: '[a-z][a-z{d}]*',
-    camel: '[a-z][a-z{d}]*(?:[A-Z{d}](?:[a-z{d}]+|$))*',
-    pascal: '[A-Z][a-z{d}]*(?:[A-Z{d}](?:[a-z{d}]+|$))*',
-    // Segments after a separator may start with a digit, matching Spectral (so
-    // "foo-2fa" is valid kebab case). The sub-pattern is `[a-z{d}]+`, not the
-    // stricter `[a-z][a-z{d}]*` which would require a letter right after the sep.
-    kebab: '[a-z][a-z{d}]*(?:-[a-z{d}]+)*',
-    cobol: '[A-Z][A-Z{d}]*(?:-[A-Z{d}]+)*',
-    snake: '[a-z][a-z{d}]*(?:_[a-z{d}]+)*',
-    macro: '[A-Z][A-Z{d}]*(?:_[A-Z{d}]+)*',
+  flat: "[a-z][a-z{d}]*",
+  camel: "[a-z][a-z{d}]*(?:[A-Z{d}](?:[a-z{d}]+|$))*",
+  pascal: "[A-Z][a-z{d}]*(?:[A-Z{d}](?:[a-z{d}]+|$))*",
+  // Segments after a separator may start with a digit, matching Spectral (so
+  // "foo-2fa" is valid kebab case). The sub-pattern is `[a-z{d}]+`, not the
+  // stricter `[a-z][a-z{d}]*` which would require a letter right after the sep.
+  kebab: "[a-z][a-z{d}]*(?:-[a-z{d}]+)*",
+  cobol: "[A-Z][A-Z{d}]*(?:-[A-Z{d}]+)*",
+  snake: "[a-z][a-z{d}]*(?:_[a-z{d}]+)*",
+  macro: "[A-Z][A-Z{d}]*(?:_[A-Z{d}]+)*"
 };
 const VALID_TYPES = Object.keys(PATTERNS);
-const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const buildRegExp = (options) => {
-    const digits = options.disallowDigits ? '' : '0-9';
-    const base = PATTERNS[options.type].replace(/\{d\}/g, digits);
-    if (!options.separator)
-        return new RegExp(`^${base}$`);
-    const sep = escapeRegExp(options.separator.char);
-    const leading = options.separator.allowLeading ? `${sep}?` : '';
-    return new RegExp(`^${leading}${base}(?:${sep}${base})*$`);
+  const digits = options.disallowDigits ? "" : "0-9";
+  const base = PATTERNS[options.type].replace(/\{d\}/g, digits);
+  if (!options.separator)
+    return new RegExp(`^${base}$`);
+  const sep = escapeRegExp(options.separator.char);
+  const leading = options.separator.allowLeading ? `${sep}?` : "";
+  return new RegExp(`^${leading}${base}(?:${sep}${base})*$`);
 };
-/** Flags a string that does not match the configured casing style. */
-export const casing = (input, options) => {
-    if (!options?.type)
-        return [];
-    // Guard an unknown `type` before it reaches `PATTERNS[type]`, which would be
-    // `undefined` and crash on `.replace`. Mirror Spectral's option schema by
-    // naming every accepted value in a single, clear error finding.
-    if (!VALID_TYPES.includes(options.type)) {
-        return [
-            {
-                message: `"casing" function and its "type" option accept the following values: ${VALID_TYPES.join(', ')}`,
-            },
-        ];
-    }
-    if (typeof input !== 'string' || input.length === 0)
-        return [];
-    // Spectral special-cases a lone separator char with `allowLeading` as valid.
-    // This is what keeps the OpenAPI root path "/" from being flagged.
-    if (input.length === 1 &&
-        options.separator !== undefined &&
-        options.separator.allowLeading === true &&
-        input === options.separator.char) {
-        return [];
-    }
-    if (!buildRegExp(options).test(input)) {
-        return [{ message: `The value must be in ${options.type} case` }];
-    }
+const casing = (input, options) => {
+  if (!options?.type)
     return [];
+  if (!VALID_TYPES.includes(options.type)) {
+    return [
+      {
+        message: `"casing" function and its "type" option accept the following values: ${VALID_TYPES.join(", ")}`
+      }
+    ];
+  }
+  if (typeof input !== "string" || input.length === 0)
+    return [];
+  if (input.length === 1 && options.separator !== void 0 && options.separator.allowLeading === true && input === options.separator.char) {
+    return [];
+  }
+  if (!buildRegExp(options).test(input)) {
+    return [{ message: `The value must be in ${options.type} case` }];
+  }
+  return [];
+};
+export {
+  casing
 };

package/dist/functions/defined.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 `undefined`. */
 export declare const defined: RulesetFunction;

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

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../core/index.js';
+import type { RulesetFunction } from '../core/types.js';
 /** Options for {@link enumeration}. */
 export type IEnumerationOptions = {
     values: unknown[];

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.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 falsy. */
 export declare const falsy: RulesetFunction;

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

@@ -1,4 +1,4 @@
-import type { FunctionRegistry } from '../core/index.js';
+import type { FunctionRegistry } from '../core/types.js';
 export { alphabetical, type IAlphabeticalOptions } from './alphabetical.js';
 export { type CasingType, casing, type ICasingOptions } from './casing.js';
 export { defined } from './defined.js';

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

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../core/index.js';
+import type { RulesetFunction } from '../core/types.js';
 /** Options for {@link length}. */
 export type ILengthOptions = {
     min?: number;

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

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

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

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../core/index.js';
+import type { RulesetFunction } from '../core/types.js';
 /** Options for {@link pattern}. */
 export type IPatternOptions = {
     match?: string;

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

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../core/index.js';
+import type { RulesetFunction } from '../core/types.js';
 /** Options for {@link schema}. */
 export type ISchemaOptions = {
     /** The JSON Schema to validate the matched value against. */