@mintlify/validation 0.1.890 → 0.1.891

package/dist/index.d.ts

@@ -2,6 +2,8 @@ import { DocsConfig, docsConfigSchema } from './mint-config/schemas/v2/index.js'
 export * from './openapi/types/endpoint.js';
 export * as OpenAPIV3_2 from './openapi/types/openapi-v3_2.js';
 export * from './openapi/OpenApiToEndpointConverter.js';
+export { getComponentNameFromRef, getSecuritySchemeNameFromFragment, } from './openapi/componentRefs.js';
+export { isComponentPathItemReference, resolvePathItemReference, } from './openapi/pathItemReferences.js';
 export { stripComponents } from './openapi/stripComponents.js';
 export { SchemaConverter } from './openapi/SchemaConverter.js';
 export { getFileLikeStringEncoding, getSchemaContentEncoding, getSchemaContentMediaType, } from './openapi/utils.js';

package/dist/index.js

@@ -22,6 +22,8 @@ import { searchableSchema } from './mint-config/schemas/v2/properties/reusable/s
 export * from './openapi/types/endpoint.js';
 export * as OpenAPIV3_2 from './openapi/types/openapi-v3_2.js';
 export * from './openapi/OpenApiToEndpointConverter.js';
+export { getComponentNameFromRef, getSecuritySchemeNameFromFragment, } from './openapi/componentRefs.js';
+export { isComponentPathItemReference, resolvePathItemReference, } from './openapi/pathItemReferences.js';
 export { stripComponents } from './openapi/stripComponents.js';
 export { SchemaConverter } from './openapi/SchemaConverter.js';
 export { getFileLikeStringEncoding, getSchemaContentEncoding, getSchemaContentMediaType, } from './openapi/utils.js';

package/dist/openapi/componentRefs.d.ts

@@ -0,0 +1,2 @@
+export declare const getComponentNameFromRef: (ref: string, section: string) => string | undefined;
+export declare const getSecuritySchemeNameFromFragment: (key: string) => string | undefined;

package/dist/openapi/componentRefs.js

@@ -0,0 +1,19 @@
+export const getComponentNameFromRef = (ref, section) => {
+    if (!ref.startsWith('#'))
+        return undefined;
+    let pointer;
+    try {
+        pointer = decodeURIComponent(ref.slice(1));
+    }
+    catch (_a) {
+        return undefined;
+    }
+    const prefix = `/components/${section}/`;
+    if (!pointer.startsWith(prefix))
+        return undefined;
+    const token = pointer.slice(prefix.length);
+    if (token.length === 0 || token.includes('/'))
+        return undefined;
+    return token.replace(/~1/g, '/').replace(/~0/g, '~');
+};
+export const getSecuritySchemeNameFromFragment = (key) => getComponentNameFromRef(key, 'securitySchemes');

package/dist/openapi/pathItemReferences.d.ts

@@ -0,0 +1,6 @@
+type PathItemRecord = Record<string, unknown>;
+export declare const resolvePathItemReference: (pathItem: object, components: unknown, seen?: Set<string>) => PathItemRecord | undefined;
+export declare const getComponentPathItemName: (pathItem: unknown) => string | undefined;
+export declare const isComponentPathItemReference: (pathItem: unknown) => boolean;
+export declare const activePathItemsOf: (pathItem: unknown) => ReadonlySet<string>;
+export {};

package/dist/openapi/pathItemReferences.js

@@ -0,0 +1,58 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { getComponentNameFromRef } from './componentRefs.js';
+import { isObject } from './utils.js';
+const getComponentPathItem = (components, name) => {
+    if (!isObject(components))
+        return undefined;
+    const section = components.pathItems;
+    if (!isObject(section))
+        return undefined;
+    const target = section[name];
+    return isObject(target) ? target : undefined;
+};
+export const resolvePathItemReference = (pathItem, components, seen = new Set()) => {
+    var _a;
+    if (!isObject(pathItem))
+        return undefined;
+    const ref = pathItem.$ref;
+    if (typeof ref !== 'string')
+        return pathItem;
+    const name = getComponentNameFromRef(ref, 'pathItems');
+    if (name === undefined || seen.has(name))
+        return undefined;
+    const target = getComponentPathItem(components, name);
+    if (target === undefined)
+        return undefined;
+    seen.add(name);
+    const { $ref: _unresolved } = target, targetFields = __rest(target, ["$ref"]);
+    const resolvedTarget = (_a = resolvePathItemReference(target, components, seen)) !== null && _a !== void 0 ? _a : targetFields;
+    const merged = structuredClone(resolvedTarget);
+    for (const [key, value] of Object.entries(pathItem)) {
+        if (key === '$ref' || value === undefined)
+            continue;
+        if (key === 'additionalOperations' && isObject(value) && isObject(merged[key])) {
+            merged[key] = Object.assign(Object.assign({}, merged[key]), value);
+            continue;
+        }
+        merged[key] = value;
+    }
+    return merged;
+};
+export const getComponentPathItemName = (pathItem) => isObject(pathItem) && typeof pathItem.$ref === 'string'
+    ? getComponentNameFromRef(pathItem.$ref, 'pathItems')
+    : undefined;
+export const isComponentPathItemReference = (pathItem) => getComponentPathItemName(pathItem) !== undefined;
+export const activePathItemsOf = (pathItem) => {
+    const name = getComponentPathItemName(pathItem);
+    return name === undefined ? new Set() : new Set([name]);
+};

package/dist/openapi/utils.d.ts

@@ -1,6 +1,7 @@
 import { OpenAPIV3_1 } from 'openapi-types';
 import { DataSchema } from './types/endpoint.js';
 import { ComponentsSection, Schema3_1, SimpleSchema, SimpleSchemaWithSubschemas } from './types/schema.js';
+export declare const isObject: (value: unknown) => value is Record<string, unknown>;
 export declare const structuredDataContentTypes: string[];
 /**
  * Returns the FileSchema contentEncoding when a string schema represents a file upload.

package/dist/openapi/utils.js

@@ -1,4 +1,5 @@
 import lcm from 'lcm';
+export const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 export const structuredDataContentTypes = [
     'multipart/form-data',
     'application/json',

package/dist/openapi/v2/buildRefUuidMap.js

@@ -12,9 +12,10 @@ export const buildRefUuidMap = (spec) => {
         'requestBodies',
         'headers',
         'securitySchemes',
+        'mediaTypes',
         'links', // TODO: add support for links
         'callbacks', // TODO: add support for callbacks
-        'pathItems', // TODO: add support for pathItems
+        'pathItems',
     ];
     const components = spec.components;
     componentsObjectKeys.forEach((key) => {

package/dist/openapi/v2/contextualHash.d.ts

@@ -0,0 +1 @@
+export declare const contextualHash: (structuralHash: string, suppressedPathItems: ReadonlySet<string>, activePathItems: ReadonlySet<string>) => string;

package/dist/openapi/v2/contextualHash.js

@@ -0,0 +1,5 @@
+import hash from 'object-hash';
+export const contextualHash = (structuralHash, suppressedPathItems, activePathItems) => {
+    const inherited = [...suppressedPathItems].filter((name) => activePathItems.has(name)).sort();
+    return inherited.length === 0 ? structuralHash : hash({ structuralHash, inherited });
+};

package/dist/openapi/v2/mapCallback.d.ts

@@ -1,8 +1,10 @@
 import { RefUuidMap, UUIDObjectHashMap, HashedNodeMap, UUID, CallbackOrRef } from './types/index.js';
-export declare const mapCallback: ({ callback, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
+export declare const mapCallback: ({ callback: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, components, activePathItems, }: {
     callback: CallbackOrRef;
     refUuidMap: RefUuidMap;
     uuidObjectHashMap: UUIDObjectHashMap;
     hashedNodeMap: HashedNodeMap;
     uuid: UUID;
-}) => void;
+    components?: unknown;
+    activePathItems?: ReadonlySet<string>;
+}) => ReadonlySet<string>;

package/dist/openapi/v2/mapCallback.js

@@ -1,44 +1,74 @@
 import hash from 'object-hash';
 import { v4 as uuidv4 } from 'uuid';
+import { getComponentNameFromRef } from '../componentRefs.js';
+import { getComponentPathItemName, resolvePathItemReference } from '../pathItemReferences.js';
+import { contextualHash } from './contextualHash.js';
 import { mapPath } from './mapPath.js';
-export const mapCallback = ({ callback, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+import { ownCopy } from './ownCopy.js';
+const referencesComponentPathItems = (value, seen = new WeakSet()) => {
+    if (typeof value !== 'object' || value === null || seen.has(value))
+        return false;
+    seen.add(value);
+    if (Array.isArray(value))
+        return value.some((item) => referencesComponentPathItems(item, seen));
+    return Object.entries(value).some(([key, child]) => (key === '$ref' &&
+        typeof child === 'string' &&
+        getComponentNameFromRef(child, 'pathItems') !== undefined) ||
+        referencesComponentPathItems(child, seen));
+};
+export const mapCallback = ({ callback: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, components, activePathItems = new Set(), }) => {
     // hash the raw object
-    const objectHash = hash(callback);
-    // map uuid and hash to uuidObjectHashMap
-    uuidObjectHashMap[uuid] = objectHash;
+    const structuralHash = hash(input);
+    const suppressedPathItems = new Set();
     // if we've seen this exact object before, skip processing
-    if (objectHash in hashedNodeMap) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        callback = objectHash;
-        return;
+    if (!referencesComponentPathItems(input) && structuralHash in hashedNodeMap) {
+        uuidObjectHashMap[uuid] = structuralHash;
+        return suppressedPathItems;
     }
+    const callback = ownCopy(input, []);
     // if ref, replace with uuid
     if ('$ref' in callback && callback.$ref) {
+        uuidObjectHashMap[uuid] = structuralHash;
         const refId = callback.$ref;
         const refUuid = refUuidMap[refId];
         if (refUuid && uuidObjectHashMap[refUuid]) {
             uuidObjectHashMap[uuid] = uuidObjectHashMap[refUuid];
-            return;
+            return suppressedPathItems;
         }
         const resolvedRefUuid = refUuid || uuidv4();
         callback.$ref = resolvedRefUuid;
-        hashedNodeMap[objectHash] = callback;
-        return;
+        hashedNodeMap[structuralHash] = callback;
+        return suppressedPathItems;
     }
     // for path item in callback, create Path node
-    Object.entries(callback).forEach(([expression, pathItem]) => {
+    Object.entries(callback).forEach(([expression, rawPathItem]) => {
+        var _a;
         const pathUuid = uuidv4();
-        mapPath({
-            pathItem: pathItem,
+        const componentName = getComponentPathItemName(rawPathItem);
+        const isCyclic = componentName !== undefined && activePathItems.has(componentName);
+        if (isCyclic)
+            suppressedPathItems.add(componentName);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- resolved items keep the PathObjectOrRef shape
+        const pathItem = structuredClone((_a = (isCyclic ? undefined : resolvePathItemReference(rawPathItem, components))) !== null && _a !== void 0 ? _a : rawPathItem);
+        const suppressedBelow = mapPath({
+            pathItem,
             refUuidMap,
             uuidObjectHashMap,
             hashedNodeMap,
             uuid: pathUuid,
             path: expression,
+            components,
+            activePathItems: componentName === undefined || isCyclic
+                ? activePathItems
+                : new Set([...activePathItems, componentName]),
         });
+        suppressedBelow.forEach((name) => suppressedPathItems.add(name));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         callback[expression] = pathUuid;
     });
     // add to hashedNodeMap
+    const objectHash = contextualHash(structuralHash, suppressedPathItems, activePathItems);
+    uuidObjectHashMap[uuid] = objectHash;
     hashedNodeMap[objectHash] = callback;
+    return suppressedPathItems;
 };

package/dist/openapi/v2/mapCallbackComponents.js

@@ -9,11 +9,12 @@ export const mapCallbackComponents = ({ spec, refUuidMap, uuidObjectHashMap, has
         const refId = `#/components/callbacks/${callbackName}`;
         const uuid = refUuidMap[refId] || uuidv4();
         mapCallback({
-            callback,
+            callback: structuredClone(callback),
             refUuidMap,
             uuidObjectHashMap,
             hashedNodeMap,
             uuid,
+            components: spec.components,
         });
     });
 };

package/dist/openapi/v2/mapExample.js

@@ -9,12 +9,7 @@ export const mapExample = ({ example, refUuidMap, uuidObjectHashMap, hashedNodeM
         example = objectHash;
         return;
     }
-    // if ref, replace with uuid
-    if ('$ref' in example && example.$ref) {
-        const refId = example.$ref;
-        const refUuid = refUuidMap[refId] || uuidv4();
-        example.$ref = refUuid;
-    }
-    // add to hashedNodeMap
-    hashedNodeMap[objectHash] = example;
+    hashedNodeMap[objectHash] =
+        '$ref' in example && example.$ref
+            ? Object.assign(Object.assign({}, example), { $ref: refUuidMap[example.$ref] || uuidv4() }) : example;
 };

package/dist/openapi/v2/mapHeader.d.ts

@@ -1,5 +1,5 @@
 import { HashedNodeMap, HeaderOrRefObject, RefUuidMap, UUIDObjectHashMap, UUID } from './types/index.js';
-export declare const mapHeader: ({ header, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
+export declare const mapHeader: ({ header: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
     header: HeaderOrRefObject;
     refUuidMap: RefUuidMap;
     uuidObjectHashMap: UUIDObjectHashMap;

package/dist/openapi/v2/mapHeader.js

@@ -3,11 +3,13 @@ import { v4 as uuidv4 } from 'uuid';
 import { mapExample } from './mapExample.js';
 import { mapMedia } from './mapMedia.js';
 import { mapSchema } from './mapSchema.js';
-export const mapHeader = ({ header, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+import { ownCopy } from './ownCopy.js';
+export const mapHeader = ({ header: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
     // hash the raw object
-    const objectHash = hash(header);
+    const objectHash = hash(input);
     // map uuid and hash to uuidObjectHashMap
     uuidObjectHashMap[uuid] = objectHash;
+    const header = ownCopy(input, ['examples', 'content', 'schema']);
     // if ref, replace with uuid
     if ('$ref' in header && header.$ref) {
         const refId = header.$ref;

package/dist/openapi/v2/mapMedia.js

@@ -1,5 +1,6 @@
 import hash from 'object-hash';
 import { v4 as uuidv4 } from 'uuid';
+import { getComponentNameFromRef } from '../componentRefs.js';
 import { mapExample } from './mapExample.js';
 import { mapSchema } from './mapSchema.js';
 export const mapMedia = ({ content, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
@@ -7,30 +8,51 @@ export const mapMedia = ({ content, refUuidMap, uuidObjectHashMap, hashedNodeMap
     uuidObjectHashMap[uuid] = objectHash;
     // if we've seen this exact object before, skip processing
     if (objectHash in hashedNodeMap) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        content = objectHash;
         return;
     }
+    if ('$ref' in content && typeof content.$ref === 'string') {
+        const name = getComponentNameFromRef(content.$ref, 'mediaTypes');
+        const refId = name === undefined ? content.$ref : `#/components/mediaTypes/${name}`;
+        const mediaRef = Object.assign(Object.assign({}, content), { $ref: refUuidMap[refId] || uuidv4() });
+        hashedNodeMap[objectHash] = mediaRef;
+        return;
+    }
+    const ownReference = (node) => typeof node === 'object' && node !== null && '$ref' in node ? Object.assign({}, node) : node;
+    const media = Object.assign(Object.assign({}, content), ('examples' in content && content.examples
+        ? {
+            examples: Object.fromEntries(Object.entries(content.examples).map(([name, example]) => [name, ownReference(example)])),
+        }
+        : {}));
+    if ('schema' in media)
+        media.schema = ownReference(media.schema);
+    if ('itemSchema' in media)
+        media.itemSchema = ownReference(media.itemSchema);
     // if schema in media, create SchemaOrRef node
-    if ('schema' in content && content.schema && typeof content.schema === 'object') {
+    if ('schema' in media && media.schema && typeof media.schema === 'object') {
+        const uuid = uuidv4();
+        mapSchema({ schema: media.schema, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        media.schema = uuid;
+    }
+    if ('itemSchema' in media && media.itemSchema && typeof media.itemSchema === 'object') {
         const uuid = uuidv4();
-        mapSchema({ schema: content.schema, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+        mapSchema({ schema: media.itemSchema, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        content.schema = uuid;
+        media.itemSchema = uuid;
     }
     // if examples in media, create ExampleOrRef node
-    if ('examples' in content && content.examples && typeof content.examples === 'object') {
-        Object.entries(content.examples).forEach(([exampleName, example]) => {
+    if ('examples' in media && media.examples && typeof media.examples === 'object') {
+        Object.entries(media.examples).forEach(([exampleName, example]) => {
             const uuid = uuidv4();
             mapExample({ example, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
-            if (content.examples) {
+            if (media.examples) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                content.examples[exampleName] = uuid;
+                media.examples[exampleName] = uuid;
             }
         });
     }
     // if encoding in media, create Encoding node
     // TODO: add support for encoding
     // add to hashedNodeMap
-    hashedNodeMap[objectHash] = content;
+    hashedNodeMap[objectHash] = media;
 };

package/dist/openapi/v2/mapMediaTypeComponents.d.ts

@@ -0,0 +1,8 @@
+import { OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+import { HashedNodeMap, RefUuidMap, UUIDObjectHashMap } from './types/index.js';
+export declare const mapMediaTypeComponents: ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }: {
+    spec: OpenAPIV3.Document | OpenAPIV3_1.Document;
+    refUuidMap: RefUuidMap;
+    uuidObjectHashMap: UUIDObjectHashMap;
+    hashedNodeMap: HashedNodeMap;
+}) => void;

package/dist/openapi/v2/mapMediaTypeComponents.js

@@ -0,0 +1,22 @@
+import { v4 as uuidv4 } from 'uuid';
+import { mapMedia } from './mapMedia.js';
+export const mapMediaTypeComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
+    const components = spec.components
+        ? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- 3.2 field on a 3.1-typed document
+            spec.components
+        : undefined;
+    const mediaTypeComponents = components === null || components === void 0 ? void 0 : components.mediaTypes;
+    if (!mediaTypeComponents)
+        return;
+    Object.entries(mediaTypeComponents).forEach(([name, content]) => {
+        const refId = `#/components/mediaTypes/${name}`;
+        const uuid = refUuidMap[refId] || uuidv4();
+        mapMedia({
+            content: structuredClone(content),
+            refUuidMap,
+            uuidObjectHashMap,
+            hashedNodeMap,
+            uuid,
+        });
+    });
+};

package/dist/openapi/v2/mapOperation.d.ts

@@ -1,6 +1,6 @@
 import { HttpMethod } from '../types/endpoint.js';
 import { OperationObject, RefUuidMap, UUIDObjectHashMap, HashedNodeMap, UUID } from './types/index.js';
-export declare const mapOperation: ({ operation, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, method, isWebhook, }: {
+export declare const mapOperation: ({ operation: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, method, isWebhook, components, activePathItems, }: {
     operation: OperationObject;
     refUuidMap: RefUuidMap;
     uuidObjectHashMap: UUIDObjectHashMap;
@@ -8,4 +8,6 @@ export declare const mapOperation: ({ operation, refUuidMap, uuidObjectHashMap,
     uuid: UUID;
     method: HttpMethod;
     isWebhook?: boolean;
-}) => void;
+    components?: unknown;
+    activePathItems?: ReadonlySet<string>;
+}) => ReadonlySet<string>;

package/dist/openapi/v2/mapOperation.js

@@ -1,15 +1,19 @@
 import hash from 'object-hash';
 import { v4 as uuidv4 } from 'uuid';
+import { contextualHash } from './contextualHash.js';
 import { mapCallback } from './mapCallback.js';
 import { mapParameter } from './mapParameter.js';
 import { mapRequestBody } from './mapRequestBody.js';
 import { mapResponse } from './mapResponse.js';
 import { mapSecurityRequirement } from './mapSecurityRequirement.js';
-export const mapOperation = ({ operation, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, method, isWebhook, }) => {
+import { ownCopy } from './ownCopy.js';
+export const mapOperation = ({ operation: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, method, isWebhook, components, activePathItems = new Set(), }) => {
     var _a;
+    const operation = ownCopy(input, ['responses', 'callbacks']);
     const type = isWebhook ? 'webhook' : 'path';
-    const objectHash = hash(Object.assign(Object.assign({}, operation), { method, type }));
-    uuidObjectHashMap[uuid] = objectHash;
+    const structuralHash = hash(Object.assign(Object.assign({}, operation), { method, type }));
+    uuidObjectHashMap[uuid] = structuralHash;
+    const suppressedPathItems = new Set();
     // parameters
     if ('parameters' in operation) {
         const parameterUuids = [];
@@ -49,7 +53,16 @@ export const mapOperation = ({ operation, refUuidMap, uuidObjectHashMap, hashedN
     if ('callbacks' in operation && operation.callbacks) {
         Object.entries(operation.callbacks).forEach(([callbackName, callback]) => {
             const uuid = uuidv4();
-            mapCallback({ callback, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid });
+            const suppressedBelow = mapCallback({
+                callback,
+                refUuidMap,
+                uuidObjectHashMap,
+                hashedNodeMap,
+                uuid,
+                components,
+                activePathItems,
+            });
+            suppressedBelow.forEach((name) => suppressedPathItems.add(name));
             if (operation.callbacks) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 operation.callbacks[callbackName] = uuid;
@@ -83,5 +96,8 @@ export const mapOperation = ({ operation, refUuidMap, uuidObjectHashMap, hashedN
     operation.method = method;
     operation.type = type;
     // add to hashedNodeMap
+    const objectHash = contextualHash(structuralHash, suppressedPathItems, activePathItems);
+    uuidObjectHashMap[uuid] = objectHash;
     hashedNodeMap[objectHash] = operation;
+    return suppressedPathItems;
 };

package/dist/openapi/v2/mapParameter.d.ts

@@ -1,5 +1,5 @@
 import { HashedNodeMap, ParameterOrRefObject, RefUuidMap, UUID, UUIDObjectHashMap } from './types/index.js';
-export declare const mapParameter: ({ parameter, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
+export declare const mapParameter: ({ parameter: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
     parameter: ParameterOrRefObject;
     refUuidMap: RefUuidMap;
     uuidObjectHashMap: UUIDObjectHashMap;

package/dist/openapi/v2/mapParameter.js

@@ -3,15 +3,15 @@ import { v4 as uuidv4 } from 'uuid';
 import { mapExample } from './mapExample.js';
 import { mapMedia } from './mapMedia.js';
 import { mapSchema } from './mapSchema.js';
-export const mapParameter = ({ parameter, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
-    const objectHash = hash(parameter);
+import { ownCopy } from './ownCopy.js';
+export const mapParameter = ({ parameter: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+    const objectHash = hash(input);
     uuidObjectHashMap[uuid] = objectHash;
     // if we've seen this exact object before, skip processing
     if (objectHash in hashedNodeMap) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        parameter = objectHash;
         return;
     }
+    const parameter = ownCopy(input, ['examples', 'content', 'schema']);
     // if ref, replace with uuid
     if ('$ref' in parameter && parameter.$ref) {
         const refId = parameter.$ref;

package/dist/openapi/v2/mapPath.d.ts

@@ -1,5 +1,5 @@
 import { RefUuidMap, UUIDObjectHashMap, HashedNodeMap, UUID, PathObjectOrRef } from './types/index.js';
-export declare const mapPath: ({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, path, isWebhook, }: {
+export declare const mapPath: ({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, path, isWebhook, components, activePathItems, }: {
     pathItem: PathObjectOrRef;
     refUuidMap: RefUuidMap;
     uuidObjectHashMap: UUIDObjectHashMap;
@@ -7,4 +7,6 @@ export declare const mapPath: ({ pathItem, refUuidMap, uuidObjectHashMap, hashed
     uuid: UUID;
     path: string;
     isWebhook?: boolean;
-}) => void;
+    components?: unknown;
+    activePathItems?: ReadonlySet<string>;
+}) => ReadonlySet<string>;

package/dist/openapi/v2/mapPath.js

@@ -1,14 +1,21 @@
 import hash from 'object-hash';
 import { v4 as uuidv4 } from 'uuid';
+import { getComponentPathItemName } from '../pathItemReferences.js';
 import { getPathItemOperations, isFixedHttpMethod } from '../types/endpoint.js';
+import { contextualHash } from './contextualHash.js';
 import { mapOperation } from './mapOperation.js';
 import { mapParameter } from './mapParameter.js';
-export const mapPath = ({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, path, isWebhook, }) => {
+export const mapPath = ({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, path, isWebhook, components, activePathItems = new Set(), }) => {
     var _a;
-    const objectHash = hash(pathItem);
-    uuidObjectHashMap[uuid] = objectHash;
+    pathItem.path = path;
+    if (isWebhook)
+        pathItem.isWebhook = true;
+    const structuralHash = hash(pathItem);
+    uuidObjectHashMap[uuid] = structuralHash;
+    const suppressedPathItems = new Set();
     if ('$ref' in pathItem && pathItem.$ref) {
-        const refId = pathItem.$ref;
+        const name = getComponentPathItemName(pathItem);
+        const refId = name === undefined ? pathItem.$ref : `#/components/pathItems/${name}`;
         const refUuid = refUuidMap[refId] || uuidv4();
         pathItem.$ref = refUuid;
     }
@@ -43,11 +50,13 @@ export const mapPath = ({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap
         pathItem.servers = serverUuids;
     }
     // process operations per http method
-    if (!('$ref' in pathItem)) {
+    {
         const additionalOperationUuids = {};
-        for (const [method, operation] of getPathItemOperations(pathItem)) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- sibling operations share the PathObject shape
+        const operations = getPathItemOperations(pathItem);
+        for (const [method, operation] of operations) {
             const operationUuid = uuidv4();
-            mapOperation({
+            const suppressedBelow = mapOperation({
                 operation,
                 refUuidMap,
                 uuidObjectHashMap,
@@ -55,7 +64,10 @@ export const mapPath = ({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap
                 uuid: operationUuid,
                 method,
                 isWebhook,
+                components,
+                activePathItems,
             });
+            suppressedBelow.forEach((name) => suppressedPathItems.add(name));
             if (isFixedHttpMethod(method)) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 pathItem[method] = operationUuid;
@@ -70,7 +82,9 @@ export const mapPath = ({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap
             pathItem.additionalOperations = additionalOperationUuids;
         }
     }
-    pathItem.path = path;
     // store path object
+    const objectHash = contextualHash(structuralHash, suppressedPathItems, activePathItems);
+    uuidObjectHashMap[uuid] = objectHash;
     hashedNodeMap[objectHash] = pathItem;
+    return suppressedPathItems;
 };

package/dist/openapi/v2/mapPathComponents.js

@@ -9,6 +9,15 @@ export const mapPathComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedN
     Object.entries(pathComponents).forEach(([name, pathItem]) => {
         const refId = `#/components/pathItems/${name}`;
         const uuid = refUuidMap[refId] || uuidv4();
-        mapPath({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, path: name });
+        mapPath({
+            pathItem: structuredClone(pathItem),
+            refUuidMap,
+            uuidObjectHashMap,
+            hashedNodeMap,
+            uuid,
+            path: name,
+            components: spec.components,
+            activePathItems: new Set([name]),
+        });
     });
 };