@amritk/lint 0.3.2 → 0.4.0

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

@@ -1,106 +1,85 @@
-import { isObject, OPERATION_METHODS } from './helpers.js';
-// Path template parameters, e.g. `{id}`. Matches Spectral's grammar so matrix
-// (`{;id}`), optional (`{id?}`), and explode (`{id*}`) markers are stripped off
-// the captured name before comparison.
+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'] : undefined;
-/**
- * Records a single `in: path` definition, emitting Spectral's `required: true`
- * and duplicate-definition findings. Returns the parameter name when it is the
- * first definition seen (so the caller registers it as usable), else undefined.
- */
+const namedPathParam = (param) => param["in"] === "path" && typeof param["name"] === "string" ? param["name"] : void 0;
 const recordPathParam = (param, definitionPath, seen, results) => {
-    const name = namedPathParam(param);
-    if (name === undefined)
-        return undefined;
-    if (param['required'] !== true) {
+  const name = namedPathParam(param);
+  if (name === void 0)
+    return void 0;
+  if (param["required"] !== true) {
+    results.push({
+      message: `Path parameter "${name}" must have a "required" property that is set to "true"`,
+      path: definitionPath
+    });
+  }
+  if (name in seen) {
+    results.push({ message: `Path parameter "${name}" must not be defined multiple times`, path: definitionPath });
+    return void 0;
+  }
+  return name;
+};
+const oasPathParam = (paths, _options, context) => {
+  if (!isObject(paths))
+    return [];
+  const results = [];
+  for (const [path, item] of Object.entries(paths)) {
+    if (!isObject(item))
+      continue;
+    const templates = [];
+    for (const match of path.matchAll(PATH_TEMPLATE)) {
+      const name = match[0].replace(/[{}?*;]/g, "");
+      if (templates.includes(name)) {
         results.push({
-            message: `Path parameter "${name}" must have a "required" property that is set to "true"`,
-            path: definitionPath,
+          message: `Path "${path}" must not use parameter "{${name}}" more than once`,
+          path: [...context.path, path]
         });
+      } else {
+        templates.push(name);
+      }
     }
-    if (name in seen) {
-        results.push({ message: `Path parameter "${name}" must not be defined multiple times`, path: definitionPath });
-        return undefined;
+    const topParams = {};
+    if (Array.isArray(item["parameters"])) {
+      item["parameters"].forEach((param, index) => {
+        if (!isObject(param))
+          return;
+        const definitionPath = [...context.path, path, "parameters", index];
+        const name = recordPathParam(param, definitionPath, topParams, results);
+        if (name !== void 0)
+          topParams[name] = definitionPath;
+      });
     }
-    return name;
-};
-/**
- * Validates path templating per operation, mirroring Spectral's `oasPathParam`.
- * For each operation on a path it checks that (a) every `{template}` in the path
- * has a matching `in: path` definition, (b) every `in: path` definition is used
- * in the template, (c) path parameters carry `required: true`, (d) a template is
- * not repeated in the path key, and (e) a parameter is not defined twice. Path
- * Item level parameters are merged with the operation's own parameters. Runs on
- * the resolved document (the rule is `resolved: true`), so `$ref`d parameters are
- * already inlined.
- */
-export const oasPathParam = (paths, _options, context) => {
-    if (!isObject(paths))
-        return [];
-    const results = [];
-    for (const [path, item] of Object.entries(paths)) {
-        if (!isObject(item))
-            continue;
-        // (d) Templates declared in the path key, deduplicated (a repeat is an error).
-        const templates = [];
-        for (const match of path.matchAll(PATH_TEMPLATE)) {
-            const name = match[0].replace(/[{}?*;]/g, '');
-            if (templates.includes(name)) {
-                results.push({
-                    message: `Path "${path}" must not use parameter "{${name}}" more than once`,
-                    path: [...context.path, path],
-                });
-            }
-            else {
-                templates.push(name);
-            }
-        }
-        // Path Item level parameters apply to every operation on the path.
-        const topParams = {};
-        if (Array.isArray(item['parameters'])) {
-            item['parameters'].forEach((param, index) => {
-                if (!isObject(param))
-                    return;
-                const definitionPath = [...context.path, path, 'parameters', index];
-                const name = recordPathParam(param, definitionPath, topParams, results);
-                if (name !== undefined)
-                    topParams[name] = definitionPath;
-            });
+    for (const [method, operation] of Object.entries(item)) {
+      if (method === "parameters" || !OPERATION_METHODS.has(method) || !isObject(operation))
+        continue;
+      const operationPath = [...context.path, path, method];
+      const operationParams = {};
+      if (Array.isArray(operation["parameters"])) {
+        operation["parameters"].forEach((param, index) => {
+          if (!isObject(param))
+            return;
+          const definitionPath = [...operationPath, "parameters", index];
+          const name = recordPathParam(param, definitionPath, operationParams, results);
+          if (name !== void 0)
+            operationParams[name] = definitionPath;
+        });
+      }
+      const defined = { ...topParams, ...operationParams };
+      for (const [name, definitionPath] of Object.entries(defined)) {
+        if (definitionPath && !templates.includes(name)) {
+          results.push({ message: `Parameter "${name}" must be used in path "${path}"`, path: definitionPath });
         }
-        for (const [method, operation] of Object.entries(item)) {
-            if (method === 'parameters' || !OPERATION_METHODS.has(method) || !isObject(operation))
-                continue;
-            const operationPath = [...context.path, path, method];
-            // Each operation is evaluated against its own params plus the shared path-item ones.
-            const operationParams = {};
-            if (Array.isArray(operation['parameters'])) {
-                operation['parameters'].forEach((param, index) => {
-                    if (!isObject(param))
-                        return;
-                    const definitionPath = [...operationPath, 'parameters', index];
-                    const name = recordPathParam(param, definitionPath, operationParams, results);
-                    if (name !== undefined)
-                        operationParams[name] = definitionPath;
-                });
-            }
-            const defined = { ...topParams, ...operationParams };
-            // (b) Every defined `in: path` parameter must appear in the path template.
-            for (const [name, definitionPath] of Object.entries(defined)) {
-                if (definitionPath && !templates.includes(name)) {
-                    results.push({ message: `Parameter "${name}" must be used in path "${path}"`, path: definitionPath });
-                }
-            }
-            // (a) Every `{template}` must have a matching definition on the operation.
-            for (const name of templates) {
-                if (!(name in defined)) {
-                    results.push({
-                        message: `Operation must define path parameter "{${name}}" as expected by path "${path}"`,
-                        path: operationPath,
-                    });
-                }
-            }
+      }
+      for (const name of templates) {
+        if (!(name in defined)) {
+          results.push({
+            message: `Operation must define path parameter "{${name}}" as expected by path "${path}"`,
+            path: operationPath
+          });
         }
+      }
     }
-    return results;
+  }
+  return results;
+};
+export {
+  oasPathParam
 };

package/dist/rules/openapi/functions/oas-schema-example-deprecated.d.ts

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../../../core/index.js';
+import type { RulesetFunction } from '../../../core/types.js';
 /**
  * Flags a Schema Object's singular `example`, deprecated in OpenAPI 3.1 (JSON
  * Schema 2020-12) in favor of the `examples` array. Targets the parent of an

package/dist/rules/openapi/functions/oas-schema-example-deprecated.js

@@ -1,42 +1,35 @@
-import { isObject } from './helpers.js';
-// JSON Schema keywords that mark an object as a Schema Object (vs. a Media Type
-// or Parameter Object, whose singular `example` is *not* deprecated in 3.1+).
-const SCHEMA_KEYWORDS = new Set([
-    'type',
-    'properties',
-    'items',
-    'allOf',
-    'anyOf',
-    'oneOf',
-    'not',
-    'enum',
-    'format',
-    'required',
-    'additionalProperties',
-    'patternProperties',
-    'prefixItems',
-    '$ref',
+import { isObject } from "./helpers.js";
+const SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+  "type",
+  "properties",
+  "items",
+  "allOf",
+  "anyOf",
+  "oneOf",
+  "not",
+  "enum",
+  "format",
+  "required",
+  "additionalProperties",
+  "patternProperties",
+  "prefixItems",
+  "$ref"
 ]);
-/**
- * Flags a Schema Object's singular `example`, deprecated in OpenAPI 3.1 (JSON
- * Schema 2020-12) in favor of the `examples` array. Targets the parent of an
- * `example` key (`$..example^`); to avoid false positives it only fires when the
- * parent looks like a Schema Object — it carries a JSON Schema keyword and is not
- * a Media Type / Parameter / Header object (those have a `schema` field and keep
- * a valid singular `example`).
- */
-export const oasSchemaExampleDeprecated = (input, _options, context) => {
-    if (!isObject(input) || input['example'] === undefined)
-        return [];
-    if ('schema' in input)
-        return [];
-    const looksLikeSchema = Object.keys(input).some((key) => SCHEMA_KEYWORDS.has(key));
-    if (!looksLikeSchema)
-        return [];
-    return [
-        {
-            message: 'Schema "example" is deprecated in OpenAPI 3.1; use "examples" instead.',
-            path: [...context.path, 'example'],
-        },
-    ];
+const oasSchemaExampleDeprecated = (input, _options, context) => {
+  if (!isObject(input) || input["example"] === void 0)
+    return [];
+  if ("schema" in input)
+    return [];
+  const looksLikeSchema = Object.keys(input).some((key) => SCHEMA_KEYWORDS.has(key));
+  if (!looksLikeSchema)
+    return [];
+  return [
+    {
+      message: 'Schema "example" is deprecated in OpenAPI 3.1; use "examples" instead.',
+      path: [...context.path, "example"]
+    }
+  ];
+};
+export {
+  oasSchemaExampleDeprecated
 };

package/dist/rules/openapi/functions/oas-schema.d.ts

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../../../core/index.js';
+import type { RulesetFunction } from '../../../core/types.js';
 import { type OasVersion } from '../schemas/index.js';
 /** Options for {@link oasSchema}: which OpenAPI version's meta-schema to validate against. */
 export type IOasSchemaOptions = {

package/dist/rules/openapi/functions/oas-schema.js

@@ -1,15 +1,10 @@
-import { schema as schemaFunction } from '../../../functions/index.js';
-import { loadOasSchema } from '../schemas/index.js';
-/**
- * Validates a whole OpenAPI document against the official structural meta-schema
- * for a given `version`, loading that version's schema lazily on first use. The
- * `*-schema` rules are format-gated to a single version, so linting a document
- * only ever reads its own version's schema file — the other versions' schemas
- * are never loaded. Delegates the actual validation to the built-in `schema`
- * function (which caches the prepared validator by schema identity).
- */
-export const oasSchema = (input, options, context) => {
-    if (!options?.version)
-        return [];
-    return schemaFunction(input, { schema: loadOasSchema(options.version) }, context);
+import { schema as schemaFunction } from "../../../functions/index.js";
+import { loadOasSchema } from "../schemas/index.js";
+const oasSchema = (input, options, context) => {
+  if (!options?.version)
+    return [];
+  return schemaFunction(input, { schema: loadOasSchema(options.version) }, context);
+};
+export {
+  oasSchema
 };

package/dist/rules/openapi/functions/oas-server-name-unique.d.ts

@@ -1,3 +1,3 @@
-import type { RulesetFunction } from '../../../core/index.js';
+import type { RulesetFunction } from '../../../core/types.js';
 /** Flags duplicate OpenAPI 3.2 Server Object `name` values across the servers array. */
 export declare const oasServerNameUnique: RulesetFunction;

package/dist/rules/openapi/functions/oas-server-name-unique.js

@@ -1,20 +1,22 @@
-import { isObject } from './helpers.js';
-/** Flags duplicate OpenAPI 3.2 Server Object `name` values across the servers array. */
-export const oasServerNameUnique = (servers, _options, context) => {
-    if (!Array.isArray(servers))
-        return [];
-    const seen = new Set();
-    const results = [];
-    servers.forEach((server, index) => {
-        if (!isObject(server) || typeof server['name'] !== 'string')
-            return;
-        if (seen.has(server['name'])) {
-            results.push({
-                message: `Server name "${server['name']}" must be unique`,
-                path: [...context.path, index, 'name'],
-            });
-        }
-        seen.add(server['name']);
-    });
-    return results;
+import { isObject } from "./helpers.js";
+const oasServerNameUnique = (servers, _options, context) => {
+  if (!Array.isArray(servers))
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  servers.forEach((server, index) => {
+    if (!isObject(server) || typeof server["name"] !== "string")
+      return;
+    if (seen.has(server["name"])) {
+      results.push({
+        message: `Server name "${server["name"]}" must be unique`,
+        path: [...context.path, index, "name"]
+      });
+    }
+    seen.add(server["name"]);
+  });
+  return results;
+};
+export {
+  oasServerNameUnique
 };

package/dist/rules/openapi/functions/oas-server-variables.d.ts

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../../../core/index.js';
+import type { RulesetFunction } from '../../../core/types.js';
 /**
  * Validates a Server Object's `variables`, mirroring Spectral's `serverVariables`:
  * every `{template}` in the URL must have a matching variable and vice versa, and

package/dist/rules/openapi/functions/oas-server-variables.js

@@ -1,52 +1,48 @@
-import { isObject } from './helpers.js';
-/**
- * Validates a Server Object's `variables`, mirroring Spectral's `serverVariables`:
- * every `{template}` in the URL must have a matching variable and vice versa, and
- * each defined variable must have a `default`, a non-empty `enum` when present,
- * and a `default` that is listed in that `enum`.
- */
-export const oasServerVariables = (server, _options, context) => {
-    if (!isObject(server) || typeof server['url'] !== 'string')
-        return [];
-    const templates = [...server['url'].matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
-    const variables = isObject(server['variables']) ? server['variables'] : {};
-    const results = [];
-    for (const template of templates) {
-        if (!(template in variables)) {
-            results.push({ message: `Server variable "${template}" is not defined`, path: [...context.path, 'variables'] });
-        }
+import { isObject } from "./helpers.js";
+const oasServerVariables = (server, _options, context) => {
+  if (!isObject(server) || typeof server["url"] !== "string")
+    return [];
+  const templates = [...server["url"].matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
+  const variables = isObject(server["variables"]) ? server["variables"] : {};
+  const results = [];
+  for (const template of templates) {
+    if (!(template in variables)) {
+      results.push({ message: `Server variable "${template}" is not defined`, path: [...context.path, "variables"] });
     }
-    for (const [name, variable] of Object.entries(variables)) {
-        if (!templates.includes(name)) {
-            results.push({
-                message: `Server variable "${name}" is not used in the URL`,
-                path: [...context.path, 'variables', name],
-            });
-        }
-        if (!isObject(variable))
-            continue;
-        const hasDefault = variable['default'] !== undefined;
-        if (!hasDefault) {
-            results.push({
-                message: `Server variable "${name}" has a missing default`,
-                path: [...context.path, 'variables', name],
-            });
-        }
-        if ('enum' in variable) {
-            const enumValues = Array.isArray(variable['enum']) ? variable['enum'] : [];
-            if (enumValues.length === 0) {
-                results.push({
-                    message: `Server variable "${name}" has an empty enum`,
-                    path: [...context.path, 'variables', name, 'enum'],
-                });
-            }
-            else if (hasDefault && !enumValues.includes(variable['default'])) {
-                results.push({
-                    message: `Server variable "${name}" has a default not listed in the enum`,
-                    path: [...context.path, 'variables', name, 'default'],
-                });
-            }
-        }
+  }
+  for (const [name, variable] of Object.entries(variables)) {
+    if (!templates.includes(name)) {
+      results.push({
+        message: `Server variable "${name}" is not used in the URL`,
+        path: [...context.path, "variables", name]
+      });
     }
-    return results;
+    if (!isObject(variable))
+      continue;
+    const hasDefault = variable["default"] !== void 0;
+    if (!hasDefault) {
+      results.push({
+        message: `Server variable "${name}" has a missing default`,
+        path: [...context.path, "variables", name]
+      });
+    }
+    if ("enum" in variable) {
+      const enumValues = Array.isArray(variable["enum"]) ? variable["enum"] : [];
+      if (enumValues.length === 0) {
+        results.push({
+          message: `Server variable "${name}" has an empty enum`,
+          path: [...context.path, "variables", name, "enum"]
+        });
+      } else if (hasDefault && !enumValues.includes(variable["default"])) {
+        results.push({
+          message: `Server variable "${name}" has a default not listed in the enum`,
+          path: [...context.path, "variables", name, "default"]
+        });
+      }
+    }
+  }
+  return results;
+};
+export {
+  oasServerVariables
 };

package/dist/rules/openapi/functions/oas-tag-defined.d.ts

@@ -1,3 +1,3 @@
-import type { RulesetFunction } from '../../../core/index.js';
+import type { RulesetFunction } from '../../../core/types.js';
 /** Ensures each operation tag is declared in the global `tags` list. */
 export declare const oasTagDefined: RulesetFunction;

package/dist/rules/openapi/functions/oas-tag-defined.js

@@ -1,21 +1,21 @@
-import { isObject } from './helpers.js';
-/** Ensures each operation tag is declared in the global `tags` list. */
-export const oasTagDefined = (input, _options, context) => {
-    const root = context.document.data;
-    if (!isObject(root) || !isObject(input))
-        return [];
-    const globalTags = new Set((Array.isArray(root['tags']) ? root['tags'] : [])
-        .map((tag) => (isObject(tag) ? tag['name'] : undefined))
-        .filter((name) => typeof name === 'string'));
-    const tags = Array.isArray(input['tags']) ? input['tags'] : [];
-    const results = [];
-    tags.forEach((tag, index) => {
-        if (typeof tag === 'string' && !globalTags.has(tag)) {
-            results.push({
-                message: `Operation tag "${tag}" is not defined in the global tags`,
-                path: [...context.path, 'tags', index],
-            });
-        }
-    });
-    return results;
+import { isObject } from "./helpers.js";
+const oasTagDefined = (input, _options, context) => {
+  const root = context.document.data;
+  if (!isObject(root) || !isObject(input))
+    return [];
+  const globalTags = new Set((Array.isArray(root["tags"]) ? root["tags"] : []).map((tag) => isObject(tag) ? tag["name"] : void 0).filter((name) => typeof name === "string"));
+  const tags = Array.isArray(input["tags"]) ? input["tags"] : [];
+  const results = [];
+  tags.forEach((tag, index) => {
+    if (typeof tag === "string" && !globalTags.has(tag)) {
+      results.push({
+        message: `Operation tag "${tag}" is not defined in the global tags`,
+        path: [...context.path, "tags", index]
+      });
+    }
+  });
+  return results;
+};
+export {
+  oasTagDefined
 };

package/dist/rules/openapi/functions/oas-tag-kind.d.ts

@@ -1,3 +1,3 @@
-import type { RulesetFunction } from '../../../core/index.js';
+import type { RulesetFunction } from '../../../core/types.js';
 /** Flags a present-but-unregistered OpenAPI 3.2 Tag Object `kind` value. */
 export declare const oasTagKind: RulesetFunction;

package/dist/rules/openapi/functions/oas-tag-kind.js

@@ -1,17 +1,17 @@
-import { isObject } from './helpers.js';
-// Registered OpenAPI 3.2 Tag `kind` values (the field is extensible via a
-// community registry, so this rule is recommended: false / opt-in).
-const REGISTERED_TAG_KINDS = new Set(['nav', 'badge', 'audience']);
-/** Flags a present-but-unregistered OpenAPI 3.2 Tag Object `kind` value. */
-export const oasTagKind = (tag, _options, context) => {
-    if (!isObject(tag) || typeof tag['kind'] !== 'string')
-        return [];
-    if (REGISTERED_TAG_KINDS.has(tag['kind']))
-        return [];
-    return [
-        {
-            message: `Tag kind "${tag['kind']}" is not a registered value (${[...REGISTERED_TAG_KINDS].join(', ')})`,
-            path: [...context.path, 'kind'],
-        },
-    ];
+import { isObject } from "./helpers.js";
+const REGISTERED_TAG_KINDS = /* @__PURE__ */ new Set(["nav", "badge", "audience"]);
+const oasTagKind = (tag, _options, context) => {
+  if (!isObject(tag) || typeof tag["kind"] !== "string")
+    return [];
+  if (REGISTERED_TAG_KINDS.has(tag["kind"]))
+    return [];
+  return [
+    {
+      message: `Tag kind "${tag["kind"]}" is not a registered value (${[...REGISTERED_TAG_KINDS].join(", ")})`,
+      path: [...context.path, "kind"]
+    }
+  ];
+};
+export {
+  oasTagKind
 };

package/dist/rules/openapi/functions/oas-tag-parent-defined.d.ts

@@ -1,4 +1,4 @@
-import type { RulesetFunction } from '../../../core/index.js';
+import type { RulesetFunction } from '../../../core/types.js';
 /**
  * Validates the OpenAPI 3.2 Tag Object `parent` hierarchy: every `parent` must
  * name a tag that exists in the top-level `tags` list, a tag must not be its own