@amritk/lint 0.0.0 → 0.2.0

package/dist/parsers/lines.js

@@ -0,0 +1,28 @@
+/**
+ * Builds a {@link LineMap} for `source`. The line-start offsets are precomputed
+ * once so each `positionAt` lookup is a binary search rather than a re-scan.
+ */
+export const createLineMap = (source) => {
+    const length = source.length;
+    // Offset at which each line starts. lineStarts[0] === 0.
+    const lineStarts = [0];
+    for (let i = 0; i < source.length; i++) {
+        if (source.charCodeAt(i) === 10 /* \n */)
+            lineStarts.push(i + 1);
+    }
+    const positionAt = (offset) => {
+        const clamped = Math.max(0, Math.min(offset, length));
+        // Binary search for the last line start <= clamped.
+        let low = 0;
+        let high = lineStarts.length - 1;
+        while (low < high) {
+            const mid = (low + high + 1) >> 1;
+            if ((lineStarts[mid] ?? 0) <= clamped)
+                low = mid;
+            else
+                high = mid - 1;
+        }
+        return { line: low, character: clamped - (lineStarts[low] ?? 0) };
+    };
+    return { positionAt };
+};

package/dist/parsers/types.d.ts

@@ -0,0 +1,50 @@
+/** A path into a parsed document: object keys and array indices from the root. */
+export type JsonPath = (string | number)[];
+/** A zero-based line/character position, matching LSP and Linter conventions. */
+export type IPosition = {
+    /** Zero-based line number. */
+    line: number;
+    /** Zero-based character offset within the line. */
+    character: number;
+};
+/** An inclusive-start, exclusive-end span between two positions. */
+export type IRange = {
+    start: IPosition;
+    end: IPosition;
+};
+/** A resolved source location — currently just the range a node occupies. */
+export type ILocation = {
+    range: IRange;
+};
+/** Severity levels, ordered most-to-least severe to match LSP's numeric scale. */
+export declare enum DiagnosticSeverity {
+    Error = 0,
+    Warning = 1,
+    Information = 2,
+    Hint = 3
+}
+/** A problem reported by the parser itself (e.g. a syntax or duplicate-key error). */
+export type IDiagnostic = {
+    code?: string | number;
+    message: string;
+    path?: JsonPath;
+    range: IRange;
+    severity: DiagnosticSeverity;
+};
+/** The result of parsing a document: its data, parser diagnostics, and a position lookup. */
+export type IParseResult<T = unknown> = {
+    data: T;
+    diagnostics: IDiagnostic[];
+    /**
+     * Returns the source location for a JSON path. When `closest` is true and the
+     * exact path is not found, walks up to the nearest ancestor that is.
+     */
+    getLocationForJsonPath(path: JsonPath, closest?: boolean): ILocation | undefined;
+};
+/** Tuning for how strictly the parser treats YAML/JSON edge cases. */
+export type IParserOptions = {
+    /** Severity for duplicate object keys. Default: error. `false`/`"off"` disables. */
+    duplicateKeys?: DiagnosticSeverity | 'off' | false;
+    /** Severity for YAML values incompatible with JSON (e.g. bigints). Default: error. */
+    incompatibleValues?: DiagnosticSeverity | 'off' | false;
+};

package/dist/parsers/types.js

@@ -0,0 +1,8 @@
+/** Severity levels, ordered most-to-least severe to match LSP's numeric scale. */
+export var DiagnosticSeverity;
+(function (DiagnosticSeverity) {
+    DiagnosticSeverity[DiagnosticSeverity["Error"] = 0] = "Error";
+    DiagnosticSeverity[DiagnosticSeverity["Warning"] = 1] = "Warning";
+    DiagnosticSeverity[DiagnosticSeverity["Information"] = 2] = "Information";
+    DiagnosticSeverity[DiagnosticSeverity["Hint"] = 3] = "Hint";
+})(DiagnosticSeverity || (DiagnosticSeverity = {}));

package/dist/parsers/yaml.d.ts

@@ -0,0 +1,6 @@
+import { type IParseResult, type IParserOptions } from './types.js';
+/**
+ * Parses YAML (a JSON superset, so this handles both) into data plus a source
+ * map, surfacing duplicate-key and incompatible-value diagnostics per `options`.
+ */
+export declare const parseYaml: <T = unknown>(source: string, options?: IParserOptions) => IParseResult<T>;

package/dist/parsers/yaml.js

@@ -0,0 +1,65 @@
+import { isMap, isPair, isScalar, isSeq, parseDocument } from '@amritk/yaml';
+import { createLineMap } from './lines.js';
+import { DiagnosticSeverity, } from './types.js';
+const pathKey = (path) => path.join('\0');
+/**
+ * Parses YAML (a JSON superset, so this handles both) into data plus a source
+ * map, surfacing duplicate-key and incompatible-value diagnostics per `options`.
+ */
+export const parseYaml = (source, options = {}) => {
+    const lineMap = createLineMap(source);
+    const dedupe = options.duplicateKeys === 'off' || options.duplicateKeys === false;
+    const doc = parseDocument(source, { uniqueKeys: !dedupe });
+    const index = new Map();
+    const rangeOf = (node) => ({
+        start: lineMap.positionAt(node.start),
+        end: lineMap.positionAt(node.end),
+    });
+    const walk = (node, path) => {
+        if (node == null)
+            return;
+        index.set(pathKey(path), rangeOf(node));
+        if (isMap(node)) {
+            for (const item of node.items) {
+                if (!isPair(item))
+                    continue;
+                const key = item.key;
+                const keyName = isScalar(key) ? key.value : String(key);
+                walk(item.value, [...path, keyName]);
+            }
+        }
+        else if (isSeq(node)) {
+            node.items.forEach((item, i) => {
+                walk(item, [...path, i]);
+            });
+        }
+    };
+    walk(doc.contents, []);
+    const data = doc.toJS();
+    const diagnostics = [];
+    const pushError = (severity, message, start, end) => {
+        diagnostics.push({
+            message,
+            severity,
+            range: { start: lineMap.positionAt(start), end: lineMap.positionAt(end) },
+        });
+    };
+    for (const err of doc.errors) {
+        pushError(DiagnosticSeverity.Error, err.message, err.start, err.end);
+    }
+    for (const warn of doc.warnings) {
+        pushError(DiagnosticSeverity.Warning, warn.message, warn.start, warn.end);
+    }
+    const getLocationForJsonPath = (path, closest = false) => {
+        const p = path.slice();
+        while (true) {
+            const range = index.get(pathKey(p));
+            if (range)
+                return { range };
+            if (!closest || p.length === 0)
+                return undefined;
+            p.pop();
+        }
+    };
+    return { data, diagnostics, getLocationForJsonPath };
+};

package/dist/rules/openapi/fixers.d.ts

@@ -0,0 +1,7 @@
+import type { FixerRegistry } from '../../fix/index.js';
+/**
+ * Auto-fixers for the mechanically-repairable OpenAPI rules, keyed by rule
+ * code. Pass these to `@amritk/lint`'s `fixDocument` (as its `fixers`), or wrap
+ * them with `createFixPlugin` for a lower-level plugin.
+ */
+export declare const oasFixers: FixerRegistry;

package/dist/rules/openapi/fixers.js

@@ -0,0 +1,189 @@
+/** Reads the value at `path` in the parsed document, or `undefined` if absent. */
+const getAtPath = (data, path) => {
+    let current = data;
+    for (const segment of path) {
+        if (current == null || typeof current !== 'object')
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+};
+const isObject = (value) => value != null && typeof value === 'object' && !Array.isArray(value);
+const stripTrailingSlash = (value) => value.replace(/\/+$/, '');
+/**
+ * `oas2-host-trailing-slash` / `oas3-server-trailing-slash`: drop the trailing
+ * slash from a string value (host or server URL).
+ */
+const trailingSlashValue = {
+    safe: true,
+    fix: ({ diagnostic, data }) => {
+        const value = getAtPath(data, diagnostic.path);
+        if (typeof value !== 'string')
+            return undefined;
+        const stripped = stripTrailingSlash(value);
+        if (stripped === value || stripped === '')
+            return undefined;
+        return { op: 'setValue', path: diagnostic.path, value: stripped };
+    },
+};
+/** `path-keys-no-trailing-slash`: rename a `paths` key to drop its trailing slash. */
+const pathKeyTrailingSlash = {
+    safe: true,
+    fix: ({ diagnostic }) => {
+        const key = diagnostic.path[diagnostic.path.length - 1];
+        if (typeof key !== 'string')
+            return undefined;
+        const stripped = stripTrailingSlash(key);
+        if (stripped === key || stripped === '')
+            return undefined;
+        return { op: 'renameProperty', path: diagnostic.path, newKey: stripped };
+    },
+};
+/** `no-$ref-siblings`: delete the sibling key that sits next to a `$ref`. */
+const refSibling = {
+    safe: true,
+    fix: ({ diagnostic }) => {
+        if (diagnostic.path.length === 0)
+            return undefined;
+        return { op: 'removeProperty', path: diagnostic.path };
+    },
+};
+/** `duplicated-entry-in-enum`: remove the later copies of each repeated enum value. */
+const duplicatedEnum = {
+    safe: true,
+    fix: ({ diagnostic, data }) => {
+        const array = getAtPath(data, diagnostic.path);
+        if (!Array.isArray(array))
+            return undefined;
+        const seen = new Set();
+        const duplicates = [];
+        array.forEach((item, index) => {
+            const key = JSON.stringify(item);
+            if (seen.has(key))
+                duplicates.push(index);
+            else
+                seen.add(key);
+        });
+        if (duplicates.length === 0)
+            return undefined;
+        return { op: 'removeItems', path: diagnostic.path, indices: duplicates };
+    },
+};
+/** `openapi-tags-alphabetical`: reorder the top-level `tags` array by `name`. */
+const tagsAlphabetical = {
+    safe: true,
+    fix: ({ diagnostic, data }) => {
+        // Findings point at the out-of-order item; the array is its parent.
+        const arrayPath = diagnostic.path.slice(0, -1);
+        const array = getAtPath(data, arrayPath);
+        if (!Array.isArray(array))
+            return undefined;
+        const nameOf = (item) => item != null && typeof item === 'object' ? String(item['name']) : String(item);
+        const order = array.map((_, index) => index).sort((a, b) => nameOf(array[a]).localeCompare(nameOf(array[b])));
+        if (order.every((value, index) => value === index))
+            return undefined;
+        return { op: 'reorderArray', path: arrayPath, order };
+    },
+};
+/** `path-not-include-query`: drop the `?query` portion from a `paths` key. */
+const pathKeyQueryString = {
+    safe: true,
+    fix: ({ diagnostic, data }) => {
+        const key = diagnostic.path[diagnostic.path.length - 1];
+        if (typeof key !== 'string')
+            return undefined;
+        const stripped = key.replace(/\?.*$/, '');
+        if (stripped === key || stripped === '')
+            return undefined;
+        // Renaming onto an existing path would collide and silently drop a path, so skip.
+        const paths = getAtPath(data, diagnostic.path.slice(0, -1));
+        if (isObject(paths) && stripped in paths)
+            return undefined;
+        return { op: 'renameProperty', path: diagnostic.path, newKey: stripped };
+    },
+};
+/** `openapi-tags-uniqueness`: remove the later copies of each repeated tag name. */
+const tagsUnique = {
+    safe: true,
+    fix: ({ diagnostic, data }) => {
+        // Findings point at `tags[index].name`, so the array sits two segments up.
+        const arrayPath = diagnostic.path.slice(0, -2);
+        const array = getAtPath(data, arrayPath);
+        if (!Array.isArray(array))
+            return undefined;
+        const seen = new Set();
+        const duplicates = [];
+        array.forEach((tag, index) => {
+            const name = isObject(tag) ? tag['name'] : undefined;
+            if (typeof name !== 'string')
+                return;
+            if (seen.has(name))
+                duplicates.push(index);
+            else
+                seen.add(name);
+        });
+        if (duplicates.length === 0)
+            return undefined;
+        return { op: 'removeItems', path: arrayPath, indices: duplicates };
+    },
+};
+/**
+ * `oas3-unused-component` / `oas2-unused-definition`: delete the unreferenced
+ * component. Marked unsafe because a component can be referenced from another
+ * document or resolved dynamically, so removing it may not be semantics-preserving
+ * — it only applies under `--fix-unsafe`.
+ */
+const unusedComponent = {
+    safe: false,
+    fix: ({ diagnostic }) => {
+        if (diagnostic.path.length === 0)
+            return undefined;
+        return { op: 'removeProperty', path: diagnostic.path };
+    },
+};
+/**
+ * `oas3_1-no-nullable`: migrate the 3.0-era `nullable` keyword to its OpenAPI
+ * 3.1 (JSON Schema 2020-12) equivalent. `nullable: false` is the schema default,
+ * so it is simply dropped; `nullable: true` folds a `"null"` member into the
+ * sibling `type` before the keyword is removed. Marked unsafe because it rewrites
+ * the schema's `type`, so it only applies under `--fix-unsafe`.
+ */
+const noNullable = {
+    safe: false,
+    fix: ({ diagnostic, data }) => {
+        const value = getAtPath(data, diagnostic.path);
+        const remove = { op: 'removeProperty', path: diagnostic.path };
+        // `nullable: false` (or any non-true value) is the default — drop the keyword.
+        if (value !== true)
+            return remove;
+        const typePath = [...diagnostic.path.slice(0, -1), 'type'];
+        const type = getAtPath(data, typePath);
+        if (typeof type === 'string' && type !== 'null') {
+            return [{ op: 'setValue', path: typePath, value: [type, 'null'] }, remove];
+        }
+        if (Array.isArray(type) && !type.includes('null')) {
+            return [{ op: 'insertItem', path: typePath, value: 'null' }, remove];
+        }
+        // No type to widen (the schema already permits any value, null included) or
+        // `null` is already allowed — removing the keyword is enough.
+        return remove;
+    },
+};
+/**
+ * Auto-fixers for the mechanically-repairable OpenAPI rules, keyed by rule
+ * code. Pass these to `@amritk/lint`'s `fixDocument` (as its `fixers`), or wrap
+ * them with `createFixPlugin` for a lower-level plugin.
+ */
+export const oasFixers = {
+    'oas2-host-trailing-slash': trailingSlashValue,
+    'oas3-server-trailing-slash': trailingSlashValue,
+    'path-keys-no-trailing-slash': pathKeyTrailingSlash,
+    'path-not-include-query': pathKeyQueryString,
+    'no-$ref-siblings': refSibling,
+    'duplicated-entry-in-enum': duplicatedEnum,
+    'openapi-tags-alphabetical': tagsAlphabetical,
+    'openapi-tags-uniqueness': tagsUnique,
+    'oas3-unused-component': unusedComponent,
+    'oas2-unused-definition': unusedComponent,
+    'oas3_1-no-nullable': noNullable,
+};

package/dist/rules/openapi/formats.d.ts

@@ -0,0 +1,13 @@
+import type { Format } from '../../core/index.js';
+/** Matches OpenAPI/Swagger 2.0 (`swagger: "2.0"`). */
+export declare const oas2: Format;
+/** Matches any OpenAPI 3.x (`openapi: 3.*`). */
+export declare const oas3: Format;
+/** Matches OpenAPI 3.0.x specifically. */
+export declare const oas3_0: Format;
+/** Matches OpenAPI 3.1.x specifically. */
+export declare const oas3_1: Format;
+/** Matches OpenAPI 3.2.x specifically. */
+export declare const oas3_2: Format;
+/** OpenAPI format detectors keyed by Loupe-compatible names. */
+export declare const oasFormats: Record<string, Format>;

package/dist/rules/openapi/formats.js

@@ -0,0 +1,23 @@
+const isObject = (value) => typeof value === 'object' && value !== null;
+const openapiVersion = (document) => isObject(document) && typeof document['openapi'] === 'string' ? document['openapi'] : undefined;
+/** Matches OpenAPI/Swagger 2.0 (`swagger: "2.0"`). */
+export const oas2 = (document) => isObject(document) && document['swagger'] === '2.0';
+/** Matches any OpenAPI 3.x (`openapi: 3.*`). */
+export const oas3 = (document) => openapiVersion(document)?.startsWith('3.') ?? false;
+/** Matches OpenAPI 3.0.x specifically. */
+export const oas3_0 = (document) => openapiVersion(document)?.startsWith('3.0') ?? false;
+/** Matches OpenAPI 3.1.x specifically. */
+export const oas3_1 = (document) => openapiVersion(document)?.startsWith('3.1') ?? false;
+/** Matches OpenAPI 3.2.x specifically. */
+export const oas3_2 = (document) => openapiVersion(document)?.startsWith('3.2') ?? false;
+/** OpenAPI format detectors keyed by Loupe-compatible names. */
+export const oasFormats = {
+    oas2,
+    oas3,
+    'oas3.0': oas3_0,
+    oas3_0,
+    'oas3.1': oas3_1,
+    oas3_1,
+    'oas3.2': oas3_2,
+    oas3_2,
+};

package/dist/rules/openapi/functions/example-validation.d.ts

@@ -0,0 +1,5 @@
+import type { RulesetFunction } from '../../../core/index.js';
+/** Validates a schema object's inline `example` against the schema itself. */
+export declare const oasSchemaExample: RulesetFunction;
+/** Validates media type / parameter `example` and `examples` against the schema. */
+export declare const oasMediaExample: RulesetFunction;

package/dist/rules/openapi/functions/example-validation.js

@@ -0,0 +1,97 @@
+import { validate } from '@amritk/runtime-validators';
+import { isObject } from './helpers.js';
+// The example schemas come from the *linted document*, so they are only known at
+// runtime. `@amritk/runtime-validators` interprets a schema directly — no
+// `ajv.compile` (whose codegen dominated lint time on large specs, recompiling
+// `$ref`-duplicated schemas tens of thousands of times) and no `new Function`,
+// so it is also CSP/edge-runtime safe. Returns undefined for a non-object or a
+// schema the validator can't build (mirrors the old skip-on-compile-failure
+// behavior).
+const buildValidator = (schema) => {
+    if (!isObject(schema))
+        return undefined;
+    try {
+        return validate(schema);
+    }
+    catch {
+        return undefined;
+    }
+};
+const buildValidatorOrNull = (schema) => buildValidator(schema) ?? null;
+// Keyed by the Schema Object node; `oasSchemaExample` validates a schema's own
+// `example` against the schema minus its `example`/`examples` keywords.
+const schemaExampleResults = new WeakMap();
+// Keyed by the Media Type Object node; `oasMediaExample` validates the media's
+// `example`/`examples` against the media's `schema`. The node (not the schema) is
+// the cache key because two media objects can share a `schema` but carry different
+// examples.
+const mediaExampleResults = new WeakMap();
+const withPath = (findings, path) => {
+    if (findings.length === 0)
+        return [];
+    return findings.map((finding) => ({ message: finding.message, path: [...path, ...finding.suffix] }));
+};
+/** Validates a schema object's inline `example` against the schema itself. */
+export const oasSchemaExample = (schema, _options, context) => {
+    if (!isObject(schema) || schema['example'] === undefined)
+        return [];
+    let findings = schemaExampleResults.get(schema);
+    if (findings === undefined) {
+        findings = [];
+        const { example, examples, ...rest } = schema;
+        void example;
+        void examples;
+        const check = buildValidatorOrNull(rest);
+        if (check) {
+            const result = check(schema['example']);
+            if (result !== true) {
+                for (const error of result.errors)
+                    findings.push({ message: `"example" ${error.message}`.trim(), suffix: ['example'] });
+            }
+        }
+        schemaExampleResults.set(schema, findings);
+    }
+    return withPath(findings, context.path);
+};
+/** Validates media type / parameter `example` and `examples` against the schema. */
+export const oasMediaExample = (media, _options, context) => {
+    if (!isObject(media) || !isObject(media['schema']))
+        return [];
+    // Skip building a validator when there is no example to check (most media
+    // objects in a large spec have a schema but no example).
+    const hasExample = media['example'] !== undefined || isObject(media['examples']);
+    if (!hasExample)
+        return [];
+    let findings = mediaExampleResults.get(media);
+    if (findings === undefined) {
+        findings = [];
+        const check = buildValidatorOrNull(media['schema']);
+        if (check) {
+            if (media['example'] !== undefined) {
+                const result = check(media['example']);
+                if (result !== true) {
+                    for (const error of result.errors)
+                        findings.push({ message: `"example" ${error.message}`.trim(), suffix: ['example'] });
+                }
+            }
+            const examples = isObject(media['examples']) ? media['examples'] : undefined;
+            if (examples) {
+                for (const [name, example] of Object.entries(examples)) {
+                    if (isObject(example) && example['value'] !== undefined) {
+                        const result = check(example['value']);
+                        if (result !== true) {
+                            for (const error of result.errors) {
+                                findings.push({
+                                    message: `Example "${name}" ${error.message}`.trim(),
+                                    suffix: ['examples', name, 'value'],
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        mediaExampleResults.set(media, findings);
+    }
+    return withPath(findings, context.path);
+};

package/dist/rules/openapi/functions/helpers.d.ts

@@ -0,0 +1,3 @@
+/** True for a non-null, non-array object (an OpenAPI "object" value). */
+export declare const isObject: (value: unknown) => value is Record<string, unknown>;
+export declare const HTTP_METHODS: Set<string>;

package/dist/rules/openapi/functions/helpers.js

@@ -0,0 +1,5 @@
+/** True for a non-null, non-array object (an OpenAPI "object" value). */
+export const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+// The eight standard HTTP methods that have a dedicated fixed field on the Path
+// Item Object. Shared by the rules that iterate a path item's operations.
+export const HTTP_METHODS = new Set(['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace']);

package/dist/rules/openapi/functions/index.d.ts

@@ -0,0 +1,24 @@
+import type { FunctionRegistry } from '../../../core/index.js';
+export { oasMediaExample, oasSchemaExample } from './example-validation.js';
+export { oasAdditionalOperations } from './oas-additional-operations.js';
+export { oasDiscriminator } from './oas-discriminator.js';
+export { oasExampleValue } from './oas-example-value.js';
+export { oasMutuallyExclusive } from './oas-mutually-exclusive.js';
+export { oasOpFormDataConsumeCheck } from './oas-op-form-data-consume-check.js';
+export { oasOpIdUnique } from './oas-op-id-unique.js';
+export { oasOpParams } from './oas-op-params.js';
+export { oasOpSecurityDefined } from './oas-op-security-defined.js';
+export { oasOpSuccessResponse } from './oas-op-success-response.js';
+export { oasPathParam } from './oas-path-param.js';
+export { type IOasSchemaOptions, oasSchema } from './oas-schema.js';
+export { oasSchemaExampleDeprecated } from './oas-schema-example-deprecated.js';
+export { oasServerNameUnique } from './oas-server-name-unique.js';
+export { oasServerVariables } from './oas-server-variables.js';
+export { oasTagDefined } from './oas-tag-defined.js';
+export { oasTagKind } from './oas-tag-kind.js';
+export { oasTagParentDefined } from './oas-tag-parent-defined.js';
+export { oasTagsUnique } from './oas-tags-unique.js';
+export { oasUnusedComponent } from './oas-unused-component.js';
+export { refSiblings } from './ref-siblings.js';
+/** The OpenAPI-specific custom functions, keyed by name for ruleset `then` references. */
+export declare const oasFunctions: FunctionRegistry;

package/dist/rules/openapi/functions/index.js

@@ -0,0 +1,67 @@
+import { oasMediaExample, oasSchemaExample } from './example-validation.js';
+import { oasAdditionalOperations } from './oas-additional-operations.js';
+import { oasDiscriminator } from './oas-discriminator.js';
+import { oasExampleValue } from './oas-example-value.js';
+import { oasMutuallyExclusive } from './oas-mutually-exclusive.js';
+import { oasOpFormDataConsumeCheck } from './oas-op-form-data-consume-check.js';
+import { oasOpIdUnique } from './oas-op-id-unique.js';
+import { oasOpParams } from './oas-op-params.js';
+import { oasOpSecurityDefined } from './oas-op-security-defined.js';
+import { oasOpSuccessResponse } from './oas-op-success-response.js';
+import { oasPathParam } from './oas-path-param.js';
+import { oasSchema } from './oas-schema.js';
+import { oasSchemaExampleDeprecated } from './oas-schema-example-deprecated.js';
+import { oasServerNameUnique } from './oas-server-name-unique.js';
+import { oasServerVariables } from './oas-server-variables.js';
+import { oasTagDefined } from './oas-tag-defined.js';
+import { oasTagKind } from './oas-tag-kind.js';
+import { oasTagParentDefined } from './oas-tag-parent-defined.js';
+import { oasTagsUnique } from './oas-tags-unique.js';
+import { oasUnusedComponent } from './oas-unused-component.js';
+import { refSiblings } from './ref-siblings.js';
+export { oasMediaExample, oasSchemaExample } from './example-validation.js';
+export { oasAdditionalOperations } from './oas-additional-operations.js';
+export { oasDiscriminator } from './oas-discriminator.js';
+export { oasExampleValue } from './oas-example-value.js';
+export { oasMutuallyExclusive } from './oas-mutually-exclusive.js';
+export { oasOpFormDataConsumeCheck } from './oas-op-form-data-consume-check.js';
+export { oasOpIdUnique } from './oas-op-id-unique.js';
+export { oasOpParams } from './oas-op-params.js';
+export { oasOpSecurityDefined } from './oas-op-security-defined.js';
+export { oasOpSuccessResponse } from './oas-op-success-response.js';
+export { oasPathParam } from './oas-path-param.js';
+export { oasSchema } from './oas-schema.js';
+export { oasSchemaExampleDeprecated } from './oas-schema-example-deprecated.js';
+export { oasServerNameUnique } from './oas-server-name-unique.js';
+export { oasServerVariables } from './oas-server-variables.js';
+export { oasTagDefined } from './oas-tag-defined.js';
+export { oasTagKind } from './oas-tag-kind.js';
+export { oasTagParentDefined } from './oas-tag-parent-defined.js';
+export { oasTagsUnique } from './oas-tags-unique.js';
+export { oasUnusedComponent } from './oas-unused-component.js';
+export { refSiblings } from './ref-siblings.js';
+/** The OpenAPI-specific custom functions, keyed by name for ruleset `then` references. */
+export const oasFunctions = {
+    refSiblings,
+    oasOpSuccessResponse,
+    oasTagDefined,
+    oasOpIdUnique,
+    oasPathParam,
+    oasOpParams,
+    oasTagsUnique,
+    oasOpSecurityDefined: oasOpSecurityDefined,
+    oasOpFormDataConsumeCheck,
+    oasDiscriminator,
+    oasServerVariables,
+    oasSchemaExample,
+    oasMediaExample,
+    oasUnusedComponent,
+    oasMutuallyExclusive: oasMutuallyExclusive,
+    oasSchema: oasSchema,
+    oasAdditionalOperations,
+    oasServerNameUnique,
+    oasTagParentDefined,
+    oasSchemaExampleDeprecated,
+    oasTagKind,
+    oasExampleValue,
+};

package/dist/rules/openapi/functions/oas-additional-operations.d.ts

@@ -0,0 +1,8 @@
+import type { RulesetFunction } from '../../../core/index.js';
+/**
+ * Flags standard HTTP methods inside an OpenAPI 3.2 `additionalOperations` map.
+ * The spec reserves that map for methods without a dedicated fixed field, so a
+ * standard method key (sent uppercase, e.g. `POST`) belongs in the lowercase
+ * fixed field (`post`) instead.
+ */
+export declare const oasAdditionalOperations: RulesetFunction;

package/dist/rules/openapi/functions/oas-additional-operations.js

@@ -0,0 +1,25 @@
+import { HTTP_METHODS, isObject } from './helpers.js';
+// HTTP methods that have a dedicated fixed field on the Path Item Object. In
+// OpenAPI 3.2 `query` joined the original eight, and these MUST NOT be redefined
+// inside the new `additionalOperations` map (which is for non-standard methods).
+const FIXED_PATH_ITEM_METHODS = new Set([...HTTP_METHODS, 'query']);
+/**
+ * Flags standard HTTP methods inside an OpenAPI 3.2 `additionalOperations` map.
+ * The spec reserves that map for methods without a dedicated fixed field, so a
+ * standard method key (sent uppercase, e.g. `POST`) belongs in the lowercase
+ * fixed field (`post`) instead.
+ */
+export const oasAdditionalOperations = (input, _options, context) => {
+    if (!isObject(input))
+        return [];
+    const results = [];
+    for (const method of Object.keys(input)) {
+        if (FIXED_PATH_ITEM_METHODS.has(method.toLowerCase())) {
+            results.push({
+                message: `"additionalOperations" must not redefine the standard method "${method}"; use the "${method.toLowerCase()}" field instead`,
+                path: [...context.path, method],
+            });
+        }
+    }
+    return results;
+};

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

@@ -0,0 +1,3 @@
+import type { RulesetFunction } from '../../../core/index.js';
+/** Validates a v2 discriminator references a required property. */
+export declare const oasDiscriminator: RulesetFunction;