@amritk/lint 0.3.2 → 0.3.3

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

@@ -1,160 +1,120 @@
-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).
-//
-// Formats are asserted (`formats: 'all'`) to match Spectral, whose example rules
-// run ajv with `ajv-formats` enabled — otherwise a format-violating example (a
-// bad `email`/`date`/`uuid`) would slip through. This mirrors the core `schema`
-// built-in's option exactly; `@amritk/runtime-validators` treats the OAS-specific
-// numeric/binary formats (`int32`/`int64`/`float`/`byte`/`binary`) as non-failing.
+import { validate } from "@amritk/runtime-validators";
+import { isObject } from "./helpers.js";
 const buildValidator = (schema) => {
-    if (!isObject(schema))
-        return undefined;
-    let validator;
+  if (!isObject(schema))
+    return void 0;
+  let validator;
+  try {
+    validator = validate(schema, { formats: "all" });
+  } catch {
+    return void 0;
+  }
+  return (input) => {
     try {
-        validator = validate(schema, { formats: 'all' });
+      return validator(input);
+    } catch {
+      return true;
     }
-    catch {
-        return undefined;
-    }
-    // A schema can carry a `$ref` the runtime validator cannot resolve (an external
-    // or cyclic ref left behind after `$ref` inlining), which throws at *run* time
-    // rather than build time. Treat that as "cannot validate — skip" (returning a
-    // valid result) so an unresolvable example schema never crashes the whole lint.
-    return (input) => {
-        try {
-            return validator(input);
-        }
-        catch {
-            return true;
-        }
-    };
+  };
 };
 const buildValidatorOrNull = (schema) => buildValidator(schema) ?? null;
-// Keyed by the Schema Object node; `oasSchemaExample` validates a schema's own
-// `example`/`default` against the schema minus its `example`/`examples` keywords.
-const schemaExampleResults = new WeakMap();
-// Keyed by the Media Type / Response Object node; `oasMediaExample` validates the
-// object's example(s) against its `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 schemaExampleResults = /* @__PURE__ */ new WeakMap();
+const mediaExampleResults = /* @__PURE__ */ new WeakMap();
 const withPath = (findings, path) => {
-    if (findings.length === 0)
-        return [];
-    return findings.map((finding) => ({ message: finding.message, path: [...path, ...finding.suffix] }));
+  if (findings.length === 0)
+    return [];
+  return findings.map((finding) => ({ message: finding.message, path: [...path, ...finding.suffix] }));
 };
-// A schema node reached via `$..[?(...)]` might be a `properties`/`patternProperties`
-// *map* whose keys happen to look like schema keywords (e.g. a property literally
-// named `type`). Those maps are not Schema Objects, so we never validate them.
 const isPropertiesMap = (path) => {
-    const tail = path[path.length - 1];
-    return tail === 'properties' || tail === 'patternProperties';
+  const tail = path[path.length - 1];
+  return tail === "properties" || tail === "patternProperties";
 };
-/** Validates a schema object's inline `example` and `default` against the schema itself. */
-export const oasSchemaExample = (schema, _options, context) => {
-    if (!isObject(schema))
-        return [];
-    if (schema['example'] === undefined && schema['default'] === undefined)
-        return [];
-    if (isPropertiesMap(context.path))
-        return [];
-    let findings = schemaExampleResults.get(schema);
-    if (findings === undefined) {
-        findings = [];
-        // `example`/`examples` are annotations, not constraints, so drop them before
-        // building the validator; `default` stays (it is not a validation keyword).
-        const { example, examples, ...rest } = schema;
-        void example;
-        void examples;
-        const check = buildValidatorOrNull(rest);
-        if (check) {
-            for (const field of ['example', 'default']) {
-                if (schema[field] === undefined)
-                    continue;
-                const result = check(schema[field]);
-                if (result !== true) {
-                    for (const error of result.errors)
-                        findings.push({ message: `"${field}" ${error.message}`.trim(), suffix: [field] });
-                }
-            }
+const oasSchemaExample = (schema, _options, context) => {
+  if (!isObject(schema))
+    return [];
+  if (schema["example"] === void 0 && schema["default"] === void 0)
+    return [];
+  if (isPropertiesMap(context.path))
+    return [];
+  let findings = schemaExampleResults.get(schema);
+  if (findings === void 0) {
+    findings = [];
+    const { example, examples, ...rest } = schema;
+    void example;
+    void examples;
+    const check = buildValidatorOrNull(rest);
+    if (check) {
+      for (const field of ["example", "default"]) {
+        if (schema[field] === void 0)
+          continue;
+        const result = check(schema[field]);
+        if (result !== true) {
+          for (const error of result.errors)
+            findings.push({ message: `"${field}" ${error.message}`.trim(), suffix: [field] });
         }
-        schemaExampleResults.set(schema, findings);
+      }
     }
-    return withPath(findings, context.path);
+    schemaExampleResults.set(schema, findings);
+  }
+  return withPath(findings, context.path);
 };
-/**
- * Validates a Media Type / Response / Parameter object's examples against its
- * `schema`. Version-split because OpenAPI 2.0 and 3.x model examples differently:
- * - OAS3: a singular `example` value plus an `examples` map of Example Objects,
- *   each of which carries the value under `value`.
- * - OAS2: `examples` is a MIME-type → value map (`{ 'application/json': value }`),
- *   with no Example Objects and no singular `example` on the media object — so the
- *   3.x logic validated nothing at all for a real 2.0 document.
- */
-export const oasMediaExample = (media, options, context) => {
-    if (!isObject(media) || !isObject(media['schema']))
-        return [];
-    const oasVersion = options?.oasVersion ?? 3;
-    // Skip building a validator when there is nothing to check — most media objects
-    // in a large spec have a schema but no example. (OAS2 only has the map form.)
-    const hasExample = (oasVersion !== 2 && 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 (oasVersion === 2)
-                collectOas2(media, check, findings);
-            else
-                collectOas3(media, check, findings);
-        }
-        mediaExampleResults.set(media, findings);
+const oasMediaExample = (media, options, context) => {
+  if (!isObject(media) || !isObject(media["schema"]))
+    return [];
+  const oasVersion = options?.oasVersion ?? 3;
+  const hasExample = oasVersion !== 2 && media["example"] !== void 0 || isObject(media["examples"]);
+  if (!hasExample)
+    return [];
+  let findings = mediaExampleResults.get(media);
+  if (findings === void 0) {
+    findings = [];
+    const check = buildValidatorOrNull(media["schema"]);
+    if (check) {
+      if (oasVersion === 2)
+        collectOas2(media, check, findings);
+      else
+        collectOas3(media, check, findings);
     }
-    return withPath(findings, context.path);
+    mediaExampleResults.set(media, findings);
+  }
+  return withPath(findings, context.path);
 };
-/** OAS2: validate each `examples[mimeType]` value against the sibling `schema`. */
 const collectOas2 = (media, check, findings) => {
-    const examples = isObject(media['examples']) ? media['examples'] : undefined;
-    if (!examples)
-        return;
-    for (const [mimeType, value] of Object.entries(examples)) {
-        const result = check(value);
-        if (result !== true) {
-            for (const error of result.errors) {
-                findings.push({ message: `Example "${mimeType}" ${error.message}`.trim(), suffix: ['examples', mimeType] });
-            }
-        }
+  const examples = isObject(media["examples"]) ? media["examples"] : void 0;
+  if (!examples)
+    return;
+  for (const [mimeType, value] of Object.entries(examples)) {
+    const result = check(value);
+    if (result !== true) {
+      for (const error of result.errors) {
+        findings.push({ message: `Example "${mimeType}" ${error.message}`.trim(), suffix: ["examples", mimeType] });
+      }
     }
+  }
 };
-/** OAS3: validate the singular `example` and each `examples[name].value` against the `schema`. */
 const collectOas3 = (media, check, findings) => {
-    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'] });
-        }
+  if (media["example"] !== void 0) {
+    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)
-        return;
-    for (const [name, example] of Object.entries(examples)) {
-        // An external-value example is fetched elsewhere, so there is nothing inline to check.
-        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'] });
-                }
-            }
+  }
+  const examples = isObject(media["examples"]) ? media["examples"] : void 0;
+  if (!examples)
+    return;
+  for (const [name, example] of Object.entries(examples)) {
+    if (isObject(example) && example["value"] !== void 0) {
+      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"] });
         }
+      }
     }
+  }
+};
+export {
+  oasMediaExample,
+  oasSchemaExample
 };

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

@@ -1,10 +1,8 @@
-/** 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']);
-// OpenAPI 3.2 promoted `query` to a fixed Path Item Object operation field, so the
-// rules that walk a path item's operations must consider it too. Including it is
-// harmless on older versions, which never carry a `query` operation, so the same
-// set works across every OpenAPI version.
-export const OPERATION_METHODS = new Set([...HTTP_METHODS, 'query']);
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const HTTP_METHODS = /* @__PURE__ */ new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
+const OPERATION_METHODS = /* @__PURE__ */ new Set([...HTTP_METHODS, "query"]);
+export {
+  HTTP_METHODS,
+  OPERATION_METHODS,
+  isObject
+};

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

@@ -1,73 +1,99 @@
-import { oasMediaExample, oasSchemaExample } from './example-validation.js';
-import { oasAdditionalOperations } from './oas-additional-operations.js';
-import { oasDiscriminator } from './oas-discriminator.js';
-import { oasExampleExternalValue } from './oas-example-external-value.js';
-import { oasExampleValue } from './oas-example-value.js';
-import { oasMutuallyExclusive } from './oas-mutually-exclusive.js';
-import { oasNoNullable } from './oas-no-nullable.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 { oasExampleExternalValue } from './oas-example-external-value.js';
-export { oasExampleValue } from './oas-example-value.js';
-export { oasMutuallyExclusive } from './oas-mutually-exclusive.js';
-export { oasNoNullable } from './oas-no-nullable.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: oasMediaExample,
-    oasUnusedComponent,
-    oasMutuallyExclusive: oasMutuallyExclusive,
-    oasNoNullable,
-    oasSchema: oasSchema,
-    oasAdditionalOperations,
-    oasServerNameUnique,
-    oasTagParentDefined,
-    oasSchemaExampleDeprecated,
-    oasTagKind,
-    oasExampleValue,
-    oasExampleExternalValue,
+import { oasMediaExample, oasSchemaExample } from "./example-validation.js";
+import { oasAdditionalOperations } from "./oas-additional-operations.js";
+import { oasDiscriminator } from "./oas-discriminator.js";
+import { oasExampleExternalValue } from "./oas-example-external-value.js";
+import { oasExampleValue } from "./oas-example-value.js";
+import { oasMutuallyExclusive } from "./oas-mutually-exclusive.js";
+import { oasNoNullable } from "./oas-no-nullable.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";
+import { oasMediaExample as oasMediaExample2, oasSchemaExample as oasSchemaExample2 } from "./example-validation.js";
+import { oasAdditionalOperations as oasAdditionalOperations2 } from "./oas-additional-operations.js";
+import { oasDiscriminator as oasDiscriminator2 } from "./oas-discriminator.js";
+import { oasExampleExternalValue as oasExampleExternalValue2 } from "./oas-example-external-value.js";
+import { oasExampleValue as oasExampleValue2 } from "./oas-example-value.js";
+import { oasMutuallyExclusive as oasMutuallyExclusive2 } from "./oas-mutually-exclusive.js";
+import { oasNoNullable as oasNoNullable2 } from "./oas-no-nullable.js";
+import { oasOpFormDataConsumeCheck as oasOpFormDataConsumeCheck2 } from "./oas-op-form-data-consume-check.js";
+import { oasOpIdUnique as oasOpIdUnique2 } from "./oas-op-id-unique.js";
+import { oasOpParams as oasOpParams2 } from "./oas-op-params.js";
+import { oasOpSecurityDefined as oasOpSecurityDefined2 } from "./oas-op-security-defined.js";
+import { oasOpSuccessResponse as oasOpSuccessResponse2 } from "./oas-op-success-response.js";
+import { oasPathParam as oasPathParam2 } from "./oas-path-param.js";
+import { oasSchema as oasSchema2 } from "./oas-schema.js";
+import { oasSchemaExampleDeprecated as oasSchemaExampleDeprecated2 } from "./oas-schema-example-deprecated.js";
+import { oasServerNameUnique as oasServerNameUnique2 } from "./oas-server-name-unique.js";
+import { oasServerVariables as oasServerVariables2 } from "./oas-server-variables.js";
+import { oasTagDefined as oasTagDefined2 } from "./oas-tag-defined.js";
+import { oasTagKind as oasTagKind2 } from "./oas-tag-kind.js";
+import { oasTagParentDefined as oasTagParentDefined2 } from "./oas-tag-parent-defined.js";
+import { oasTagsUnique as oasTagsUnique2 } from "./oas-tags-unique.js";
+import { oasUnusedComponent as oasUnusedComponent2 } from "./oas-unused-component.js";
+import { refSiblings as refSiblings2 } from "./ref-siblings.js";
+const oasFunctions = {
+  refSiblings,
+  oasOpSuccessResponse,
+  oasTagDefined,
+  oasOpIdUnique,
+  oasPathParam,
+  oasOpParams,
+  oasTagsUnique,
+  oasOpSecurityDefined,
+  oasOpFormDataConsumeCheck,
+  oasDiscriminator,
+  oasServerVariables,
+  oasSchemaExample,
+  oasMediaExample,
+  oasUnusedComponent,
+  oasMutuallyExclusive,
+  oasNoNullable,
+  oasSchema,
+  oasAdditionalOperations,
+  oasServerNameUnique,
+  oasTagParentDefined,
+  oasSchemaExampleDeprecated,
+  oasTagKind,
+  oasExampleValue,
+  oasExampleExternalValue
+};
+export {
+  oasAdditionalOperations2 as oasAdditionalOperations,
+  oasDiscriminator2 as oasDiscriminator,
+  oasExampleExternalValue2 as oasExampleExternalValue,
+  oasExampleValue2 as oasExampleValue,
+  oasFunctions,
+  oasMediaExample2 as oasMediaExample,
+  oasMutuallyExclusive2 as oasMutuallyExclusive,
+  oasNoNullable2 as oasNoNullable,
+  oasOpFormDataConsumeCheck2 as oasOpFormDataConsumeCheck,
+  oasOpIdUnique2 as oasOpIdUnique,
+  oasOpParams2 as oasOpParams,
+  oasOpSecurityDefined2 as oasOpSecurityDefined,
+  oasOpSuccessResponse2 as oasOpSuccessResponse,
+  oasPathParam2 as oasPathParam,
+  oasSchema2 as oasSchema,
+  oasSchemaExample2 as oasSchemaExample,
+  oasSchemaExampleDeprecated2 as oasSchemaExampleDeprecated,
+  oasServerNameUnique2 as oasServerNameUnique,
+  oasServerVariables2 as oasServerVariables,
+  oasTagDefined2 as oasTagDefined,
+  oasTagKind2 as oasTagKind,
+  oasTagParentDefined2 as oasTagParentDefined,
+  oasTagsUnique2 as oasTagsUnique,
+  oasUnusedComponent2 as oasUnusedComponent,
+  refSiblings2 as refSiblings
 };

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

@@ -1,25 +1,19 @@
-import { isObject, OPERATION_METHODS } from './helpers.js';
-// Methods that have a dedicated fixed field on the Path Item Object (the eight
-// standard methods plus 3.2's `query`). These MUST NOT be redefined inside the
-// new `additionalOperations` map, which is reserved for non-standard methods.
+import { isObject, OPERATION_METHODS } from "./helpers.js";
 const FIXED_PATH_ITEM_METHODS = OPERATION_METHODS;
-/**
- * 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],
-            });
-        }
+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;
+  }
+  return results;
+};
+export {
+  oasAdditionalOperations
 };

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

@@ -1,23 +1,25 @@
-import { isObject } from './helpers.js';
-/** Validates a v2 discriminator references a required property. */
-export const oasDiscriminator = (schema, _options, context) => {
-    if (!isObject(schema) || typeof schema['discriminator'] !== 'string')
-        return [];
-    const property = schema['discriminator'];
-    const required = Array.isArray(schema['required']) ? schema['required'] : [];
-    const properties = isObject(schema['properties']) ? schema['properties'] : {};
-    const results = [];
-    if (!(property in properties)) {
-        results.push({
-            message: `Discriminator "${property}" must be defined in properties`,
-            path: [...context.path, 'discriminator'],
-        });
-    }
-    if (!required.includes(property)) {
-        results.push({
-            message: `Discriminator "${property}" must be a required property`,
-            path: [...context.path, 'discriminator'],
-        });
-    }
-    return results;
+import { isObject } from "./helpers.js";
+const oasDiscriminator = (schema, _options, context) => {
+  if (!isObject(schema) || typeof schema["discriminator"] !== "string")
+    return [];
+  const property = schema["discriminator"];
+  const required = Array.isArray(schema["required"]) ? schema["required"] : [];
+  const properties = isObject(schema["properties"]) ? schema["properties"] : {};
+  const results = [];
+  if (!(property in properties)) {
+    results.push({
+      message: `Discriminator "${property}" must be defined in properties`,
+      path: [...context.path, "discriminator"]
+    });
+  }
+  if (!required.includes(property)) {
+    results.push({
+      message: `Discriminator "${property}" must be a required property`,
+      path: [...context.path, "discriminator"]
+    });
+  }
+  return results;
+};
+export {
+  oasDiscriminator
 };

package/dist/rules/openapi/functions/oas-example-external-value.js

@@ -1,23 +1,15 @@
-import { isObject } from './helpers.js';
-/**
- * Enforces that an Example Object carries exactly one inline value source. Across
- * all of OpenAPI 3.x an Example must use either `value` or `externalValue` (not
- * both, not neither). OpenAPI 3.2 added `dataValue`/`serializedValue` as further
- * ways to supply the example, so their presence also satisfies the "has an
- * example" requirement — otherwise a valid 3.2 `dataValue`-only example would be
- * wrongly flagged. The mutual exclusivity of the new fields is policed separately
- * by `oas3_2-example-value`.
- */
-export const oasExampleExternalValue = (example) => {
-    if (!isObject(example))
-        return [];
-    // A 3.2 dataValue/serializedValue already provides the example, so value /
-    // externalValue are optional in that case.
-    if (example['dataValue'] !== undefined || example['serializedValue'] !== undefined)
-        return [];
-    const present = ['value', 'externalValue'].filter((property) => property in example);
-    if (present.length !== 1) {
-        return [{ message: 'Example object must have exactly one of "value" or "externalValue"' }];
-    }
+import { isObject } from "./helpers.js";
+const oasExampleExternalValue = (example) => {
+  if (!isObject(example))
     return [];
+  if (example["dataValue"] !== void 0 || example["serializedValue"] !== void 0)
+    return [];
+  const present = ["value", "externalValue"].filter((property) => property in example);
+  if (present.length !== 1) {
+    return [{ message: 'Example object must have exactly one of "value" or "externalValue"' }];
+  }
+  return [];
+};
+export {
+  oasExampleExternalValue
 };