@redocly/openapi-core 1.0.0-beta.100

package/lib/utils.js

@@ -0,0 +1,177 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMatchingStatusCodeRange = exports.assignExisting = exports.isNotString = exports.isString = exports.isNotEmptyObject = exports.slash = exports.isPathParameter = exports.readFileAsStringSync = exports.isSingular = exports.validateMimeTypeOAS3 = exports.validateMimeType = exports.splitCamelCaseIntoWords = exports.omitObjectProps = exports.pickObjectProps = exports.readFileFromUrl = exports.isEmptyArray = exports.isEmptyObject = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
+const fs = require("fs");
+const minimatch = require("minimatch");
+const node_fetch_1 = require("node-fetch");
+const pluralize = require("pluralize");
+const js_yaml_1 = require("./js-yaml");
+const config_1 = require("./config");
+var js_yaml_2 = require("./js-yaml");
+Object.defineProperty(exports, "parseYaml", { enumerable: true, get: function () { return js_yaml_2.parseYaml; } });
+Object.defineProperty(exports, "stringifyYaml", { enumerable: true, get: function () { return js_yaml_2.stringifyYaml; } });
+function pushStack(head, value) {
+    return { prev: head, value };
+}
+exports.pushStack = pushStack;
+function popStack(head) {
+    var _a;
+    return (_a = head === null || head === void 0 ? void 0 : head.prev) !== null && _a !== void 0 ? _a : null;
+}
+exports.popStack = popStack;
+function loadYaml(filename) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const contents = yield fs.promises.readFile(filename, 'utf-8');
+        return js_yaml_1.parseYaml(contents);
+    });
+}
+exports.loadYaml = loadYaml;
+function notUndefined(x) {
+    return x !== undefined;
+}
+exports.notUndefined = notUndefined;
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+exports.isPlainObject = isPlainObject;
+function isEmptyObject(value) {
+    return isPlainObject(value) && Object.keys(value).length === 0;
+}
+exports.isEmptyObject = isEmptyObject;
+function isEmptyArray(value) {
+    return Array.isArray(value) && value.length === 0;
+}
+exports.isEmptyArray = isEmptyArray;
+function readFileFromUrl(url, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const headers = {};
+        for (const header of config.headers) {
+            if (match(url, header.matches)) {
+                headers[header.name] =
+                    header.envVariable !== undefined ? config_1.env[header.envVariable] || '' : header.value;
+            }
+        }
+        const req = yield (config.customFetch || node_fetch_1.default)(url, {
+            headers: headers,
+        });
+        if (!req.ok) {
+            throw new Error(`Failed to load ${url}: ${req.status} ${req.statusText}`);
+        }
+        return { body: yield req.text(), mimeType: req.headers.get('content-type') };
+    });
+}
+exports.readFileFromUrl = readFileFromUrl;
+function match(url, pattern) {
+    if (!pattern.match(/^https?:\/\//)) {
+        // if pattern doesn't specify protocol directly, do not match against it
+        url = url.replace(/^https?:\/\//, '');
+    }
+    return minimatch(url, pattern);
+}
+function pickObjectProps(object, keys) {
+    return Object.fromEntries(keys.filter((key) => key in object).map((key) => [key, object[key]]));
+}
+exports.pickObjectProps = pickObjectProps;
+function omitObjectProps(object, keys) {
+    return Object.fromEntries(Object.entries(object).filter(([key]) => !keys.includes(key)));
+}
+exports.omitObjectProps = omitObjectProps;
+function splitCamelCaseIntoWords(str) {
+    const camel = str
+        .split(/(?:[-._])|([A-Z][a-z]+)/)
+        .filter(Boolean)
+        .map((item) => item.toLocaleLowerCase());
+    const caps = str
+        .split(/([A-Z]{2,})/)
+        .filter((e) => e && e === e.toUpperCase())
+        .map((item) => item.toLocaleLowerCase());
+    return new Set([...camel, ...caps]);
+}
+exports.splitCamelCaseIntoWords = splitCamelCaseIntoWords;
+function validateMimeType({ type, value }, { report, location }, allowedValues) {
+    const ruleType = type === 'consumes' ? 'request' : 'response';
+    if (!allowedValues)
+        throw new Error(`Parameter "allowedValues" is not provided for "${ruleType}-mime-type" rule`);
+    if (!value[type])
+        return;
+    for (const mime of value[type]) {
+        if (!allowedValues.includes(mime)) {
+            report({
+                message: `Mime type "${mime}" is not allowed`,
+                location: location.child(value[type].indexOf(mime)).key(),
+            });
+        }
+    }
+}
+exports.validateMimeType = validateMimeType;
+function validateMimeTypeOAS3({ type, value }, { report, location }, allowedValues) {
+    const ruleType = type === 'consumes' ? 'request' : 'response';
+    if (!allowedValues)
+        throw new Error(`Parameter "allowedValues" is not provided for "${ruleType}-mime-type" rule`);
+    if (!value.content)
+        return;
+    for (const mime of Object.keys(value.content)) {
+        if (!allowedValues.includes(mime)) {
+            report({
+                message: `Mime type "${mime}" is not allowed`,
+                location: location.child('content').child(mime).key(),
+            });
+        }
+    }
+}
+exports.validateMimeTypeOAS3 = validateMimeTypeOAS3;
+function isSingular(path) {
+    return pluralize.isSingular(path);
+}
+exports.isSingular = isSingular;
+function readFileAsStringSync(filePath) {
+    return fs.readFileSync(filePath, 'utf-8');
+}
+exports.readFileAsStringSync = readFileAsStringSync;
+function isPathParameter(pathSegment) {
+    return pathSegment.startsWith('{') && pathSegment.endsWith('}');
+}
+exports.isPathParameter = isPathParameter;
+/**
+ * Convert Windows backslash paths to slash paths: foo\\bar ➔ foo/bar
+ */
+function slash(path) {
+    const isExtendedLengthPath = /^\\\\\?\\/.test(path);
+    if (isExtendedLengthPath) {
+        return path;
+    }
+    return path.replace(/\\/g, '/');
+}
+exports.slash = slash;
+function isNotEmptyObject(obj) {
+    return !!obj && Object.keys(obj).length > 0;
+}
+exports.isNotEmptyObject = isNotEmptyObject;
+// TODO: use it everywhere
+function isString(value) {
+    return typeof value === 'string';
+}
+exports.isString = isString;
+function isNotString(value) {
+    return !isString(value);
+}
+exports.isNotString = isNotString;
+function assignExisting(target, obj) {
+    for (let k of Object.keys(obj)) {
+        if (target.hasOwnProperty(k)) {
+            target[k] = obj[k];
+        }
+    }
+}
+exports.assignExisting = assignExisting;
+const getMatchingStatusCodeRange = (code) => `${code}`.replace(/^(\d)\d\d$/, (_, firstDigit) => `${firstDigit}XX`);
+exports.getMatchingStatusCodeRange = getMatchingStatusCodeRange;

package/lib/visitors.d.ts

@@ -0,0 +1,175 @@
+import type { Oas3Definition, Oas3ExternalDocs, Oas3Info, Oas3Contact, Oas3Components, Oas3License, Oas3Schema, Oas3Header, Oas3Parameter, Oas3Operation, Oas3PathItem, Oas3ServerVariable, Oas3Server, Oas3MediaType, Oas3Response, Oas3Example, Oas3RequestBody, Oas3Tag, OasRef, Oas3SecurityScheme, Oas3SecurityRequirement, Oas3Encoding, Oas3Link, Oas3Xml, Oas3Discriminator, Oas3Callback } from './typings/openapi';
+import { Oas2Definition, Oas2Tag, Oas2ExternalDocs, Oas2SecurityRequirement, Oas2Info, Oas2Contact, Oas2License, Oas2PathItem, Oas2Operation, Oas2Header, Oas2Response, Oas2Schema, Oas2Xml, Oas2Parameter, Oas2SecurityScheme } from './typings/swagger';
+import { NormalizedNodeType } from './types';
+import { Stack } from './utils';
+import { UserContext, ResolveResult, ProblemSeverity } from './walk';
+import { Location } from './ref-utils';
+export declare type VisitFunction<T> = (node: T, ctx: UserContext & {
+    ignoreNextVisitorsOnNode: () => void;
+}, parents?: any, context?: any) => void;
+declare type VisitRefFunction = (node: OasRef, ctx: UserContext, resolved: ResolveResult<any>) => void;
+declare type SkipFunction<T> = (node: T, key: string | number) => boolean;
+declare type VisitObject<T> = {
+    enter?: VisitFunction<T>;
+    leave?: VisitFunction<T>;
+    skip?: SkipFunction<T>;
+};
+declare type NestedVisitObject<T, P> = VisitObject<T> & NestedVisitor<P>;
+declare type VisitFunctionOrObject<T> = VisitFunction<T> | VisitObject<T>;
+declare type VisitorNode<T extends any> = {
+    ruleId: string;
+    severity: ProblemSeverity;
+    context: VisitorLevelContext | VisitorSkippedLevelContext;
+    depth: number;
+    visit: VisitFunction<T>;
+    skip?: SkipFunction<T>;
+};
+declare type VisitorRefNode = {
+    ruleId: string;
+    severity: ProblemSeverity;
+    context: VisitorLevelContext;
+    depth: number;
+    visit: VisitRefFunction;
+};
+export declare type VisitorLevelContext = {
+    isSkippedLevel: false;
+    type: NormalizedNodeType;
+    parent: VisitorLevelContext | null;
+    activatedOn: Stack<{
+        node?: any;
+        withParentNode?: any;
+        skipped: boolean;
+        nextLevelTypeActivated: Stack<NormalizedNodeType>;
+        location?: Location;
+    }>;
+};
+export declare type VisitorSkippedLevelContext = {
+    isSkippedLevel: true;
+    parent: VisitorLevelContext;
+    seen: Set<any>;
+};
+declare type NormalizeVisitor<Fn> = Fn extends VisitFunction<infer T> ? VisitorNode<T> : never;
+export declare type BaseVisitor = {
+    any?: {
+        enter?: VisitFunction<any>;
+        leave?: VisitFunction<any>;
+        skip?: SkipFunction<any>;
+    } | VisitFunction<any>;
+    ref?: {
+        enter?: VisitRefFunction;
+        leave?: VisitRefFunction;
+    } | VisitRefFunction;
+};
+declare type Oas3FlatVisitor = {
+    DefinitionRoot?: VisitFunctionOrObject<Oas3Definition>;
+    Tag?: VisitFunctionOrObject<Oas3Tag>;
+    ExternalDocs?: VisitFunctionOrObject<Oas3ExternalDocs>;
+    Server?: VisitFunctionOrObject<Oas3Server>;
+    ServerVariable?: VisitFunctionOrObject<Oas3ServerVariable>;
+    SecurityRequirement?: VisitFunctionOrObject<Oas3SecurityRequirement>;
+    Info?: VisitFunctionOrObject<Oas3Info>;
+    Contact?: VisitFunctionOrObject<Oas3Contact>;
+    License?: VisitFunctionOrObject<Oas3License>;
+    PathMap?: VisitFunctionOrObject<Record<string, Oas3PathItem>>;
+    PathItem?: VisitFunctionOrObject<Oas3PathItem>;
+    Callback?: VisitFunctionOrObject<Record<string, Oas3PathItem>>;
+    Parameter?: VisitFunctionOrObject<Oas3Parameter>;
+    Operation?: VisitFunctionOrObject<Oas3Operation>;
+    RequestBody?: VisitFunctionOrObject<Oas3RequestBody>;
+    MediaTypeMap?: VisitFunctionOrObject<Record<string, Oas3MediaType>>;
+    MediaType?: VisitFunctionOrObject<Oas3MediaType>;
+    Example?: VisitFunctionOrObject<Oas3Example>;
+    Encoding?: VisitFunctionOrObject<Oas3Encoding>;
+    Header?: VisitFunctionOrObject<Oas3Header>;
+    ResponsesMap?: VisitFunctionOrObject<Record<string, Oas3Response>>;
+    Response?: VisitFunctionOrObject<Oas3Response>;
+    Link?: VisitFunctionOrObject<Oas3Link>;
+    Schema?: VisitFunctionOrObject<Oas3Schema>;
+    Xml?: VisitFunctionOrObject<Oas3Xml>;
+    SchemaProperties?: VisitFunctionOrObject<Record<string, Oas3Schema>>;
+    DiscriminatorMapping?: VisitFunctionOrObject<Record<string, string>>;
+    Discriminator?: VisitFunctionOrObject<Oas3Discriminator>;
+    Components?: VisitFunctionOrObject<Oas3Components>;
+    NamedSchemas?: VisitFunctionOrObject<Record<string, Oas3Schema>>;
+    NamedResponses?: VisitFunctionOrObject<Record<string, Oas3Response>>;
+    NamedParameters?: VisitFunctionOrObject<Record<string, Oas3Parameter>>;
+    NamedExamples?: VisitFunctionOrObject<Record<string, Oas3Example>>;
+    NamedRequestBodies?: VisitFunctionOrObject<Record<string, Oas3RequestBody>>;
+    NamedHeaders?: VisitFunctionOrObject<Record<string, Oas3Header>>;
+    NamedSecuritySchemes?: VisitFunctionOrObject<Record<string, Oas3SecurityScheme>>;
+    NamedLinks?: VisitFunctionOrObject<Record<string, Oas3Link>>;
+    NamedCallbacks?: VisitFunctionOrObject<Record<string, Oas3Callback>>;
+    ImplicitFlow?: VisitFunctionOrObject<Oas3SecurityScheme['flows']['implicit']>;
+    PasswordFlow?: VisitFunctionOrObject<Oas3SecurityScheme['flows']['password']>;
+    ClientCredentials?: VisitFunctionOrObject<Oas3SecurityScheme['flows']['clientCredentials']>;
+    AuthorizationCode?: VisitFunctionOrObject<Oas3SecurityScheme['flows']['authorizationCode']>;
+    SecuritySchemeFlows?: VisitFunctionOrObject<Oas3SecurityScheme['flows']>;
+    SecurityScheme?: VisitFunctionOrObject<Oas3SecurityScheme>;
+};
+declare type Oas2FlatVisitor = {
+    DefinitionRoot?: VisitFunctionOrObject<Oas2Definition>;
+    Tag?: VisitFunctionOrObject<Oas2Tag>;
+    ExternalDocs?: VisitFunctionOrObject<Oas2ExternalDocs>;
+    SecurityRequirement?: VisitFunctionOrObject<Oas2SecurityRequirement>;
+    Info?: VisitFunctionOrObject<Oas2Info>;
+    Contact?: VisitFunctionOrObject<Oas2Contact>;
+    License?: VisitFunctionOrObject<Oas2License>;
+    PathMap?: VisitFunctionOrObject<Record<string, Oas2PathItem>>;
+    PathItem?: VisitFunctionOrObject<Oas2PathItem>;
+    Parameter?: VisitFunctionOrObject<any>;
+    Operation?: VisitFunctionOrObject<Oas2Operation>;
+    Examples?: VisitFunctionOrObject<Record<string, any>>;
+    Header?: VisitFunctionOrObject<Oas2Header>;
+    ResponsesMap?: VisitFunctionOrObject<Record<string, Oas2Response>>;
+    Response?: VisitFunctionOrObject<Oas2Response>;
+    Schema?: VisitFunctionOrObject<Oas2Schema>;
+    Xml?: VisitFunctionOrObject<Oas2Xml>;
+    SchemaProperties?: VisitFunctionOrObject<Record<string, Oas2Schema>>;
+    NamedSchemas?: VisitFunctionOrObject<Record<string, Oas2Schema>>;
+    NamedResponses?: VisitFunctionOrObject<Record<string, Oas2Response>>;
+    NamedParameters?: VisitFunctionOrObject<Record<string, Oas2Parameter>>;
+    SecurityScheme?: VisitFunctionOrObject<Oas2SecurityScheme>;
+};
+declare type Oas3NestedVisitor = {
+    [T in keyof Oas3FlatVisitor]: Oas3FlatVisitor[T] extends Function ? Oas3FlatVisitor[T] : Oas3FlatVisitor[T] & NestedVisitor<Oas3NestedVisitor>;
+};
+declare type Oas2NestedVisitor = {
+    [T in keyof Oas2FlatVisitor]: Oas2FlatVisitor[T] extends Function ? Oas2FlatVisitor[T] : Oas2FlatVisitor[T] & NestedVisitor<Oas2NestedVisitor>;
+};
+export declare type Oas3Visitor = BaseVisitor & Oas3NestedVisitor & Record<string, VisitFunction<any> | NestedVisitObject<any, Oas3NestedVisitor>>;
+export declare type Oas2Visitor = BaseVisitor & Oas2NestedVisitor & Record<string, VisitFunction<any> | NestedVisitObject<any, Oas2NestedVisitor>>;
+export declare type Oas3TransformVisitor = BaseVisitor & Oas3FlatVisitor & Record<string, VisitFunction<any> | VisitObject<any>>;
+export declare type Oas2TransformVisitor = BaseVisitor & Oas2FlatVisitor & Record<string, VisitFunction<any> | VisitObject<any>>;
+export declare type NestedVisitor<T> = Exclude<T, 'any' | 'ref' | 'DefinitionRoot'>;
+export declare type NormalizedOasVisitors<T extends BaseVisitor> = {
+    [V in keyof T]-?: {
+        enter: Array<NormalizeVisitor<T[V]>>;
+        leave: Array<NormalizeVisitor<T[V]>>;
+    };
+} & {
+    ref: {
+        enter: Array<VisitorRefNode>;
+        leave: Array<VisitorRefNode>;
+    };
+    [k: string]: {
+        enter: Array<VisitorNode<any>>;
+        leave: Array<VisitorNode<any>>;
+    };
+};
+export declare type Oas3Rule = (options: Record<string, any>) => Oas3Visitor | Oas3Visitor[];
+export declare type Oas2Rule = (options: Record<string, any>) => Oas2Visitor | Oas2Visitor[];
+export declare type Oas3Preprocessor = (options: Record<string, any>) => Oas3TransformVisitor;
+export declare type Oas2Preprocessor = (options: Record<string, any>) => Oas2TransformVisitor;
+export declare type Oas3Decorator = (options: Record<string, any>) => Oas3TransformVisitor;
+export declare type Oas2Decorator = (options: Record<string, any>) => Oas2TransformVisitor;
+export declare type OasRule = Oas3Rule;
+export declare type OasPreprocessor = Oas3Preprocessor;
+export declare type OasDecorator = Oas3Decorator;
+export declare type RuleInstanceConfig = {
+    ruleId: string;
+    severity: ProblemSeverity;
+};
+export declare function normalizeVisitors<T extends BaseVisitor>(visitorsConfig: (RuleInstanceConfig & {
+    visitor: NestedVisitObject<any, T>;
+})[], types: Record<keyof T, NormalizedNodeType>): NormalizedOasVisitors<T>;
+export {};

package/lib/visitors.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeVisitors = void 0;
+function normalizeVisitors(visitorsConfig, types) {
+    const normalizedVisitors = {};
+    normalizedVisitors.any = {
+        enter: [],
+        leave: [],
+    };
+    for (const typeName of Object.keys(types)) {
+        normalizedVisitors[typeName] = {
+            enter: [],
+            leave: [],
+        };
+    }
+    normalizedVisitors.ref = {
+        enter: [],
+        leave: [],
+    };
+    for (const { ruleId, severity, visitor } of visitorsConfig) {
+        normalizeVisitorLevel({ ruleId, severity }, visitor, null);
+    }
+    for (const v of Object.keys(normalizedVisitors)) {
+        normalizedVisitors[v].enter.sort((a, b) => b.depth - a.depth);
+        normalizedVisitors[v].leave.sort((a, b) => a.depth - b.depth);
+    }
+    return normalizedVisitors;
+    function addWeakNodes(ruleConf, from, to, parentContext, stack = []) {
+        if (stack.includes(from))
+            return;
+        stack = [...stack, from];
+        const possibleChildren = new Set();
+        for (let type of Object.values(from.properties)) {
+            if (type === to) {
+                addWeakFromStack(ruleConf, stack);
+                continue;
+            }
+            if (typeof type === 'object' && type !== null && type.name) {
+                possibleChildren.add(type);
+            }
+        }
+        if (from.additionalProperties && typeof from.additionalProperties !== 'function') {
+            if (from.additionalProperties === to) {
+                addWeakFromStack(ruleConf, stack);
+            }
+            else if (from.additionalProperties.name !== undefined) {
+                possibleChildren.add(from.additionalProperties);
+            }
+        }
+        if (from.items) {
+            if (from.items === to) {
+                addWeakFromStack(ruleConf, stack);
+            }
+            else if (from.items.name !== undefined) {
+                possibleChildren.add(from.items);
+            }
+        }
+        for (let fromType of Array.from(possibleChildren.values())) {
+            addWeakNodes(ruleConf, fromType, to, parentContext, stack);
+        }
+        function addWeakFromStack(ruleConf, stack) {
+            for (const interType of stack.slice(1)) {
+                normalizedVisitors[interType.name] =
+                    normalizedVisitors[interType.name] ||
+                        {
+                            enter: [],
+                            leave: [],
+                        };
+                normalizedVisitors[interType.name].enter.push(Object.assign(Object.assign({}, ruleConf), { visit: () => undefined, depth: 0, context: {
+                        isSkippedLevel: true,
+                        seen: new Set(),
+                        parent: parentContext,
+                    } }));
+            }
+        }
+    }
+    function normalizeVisitorLevel(ruleConf, visitor, parentContext, depth = 0) {
+        const visitorKeys = Object.keys(types);
+        if (depth === 0) {
+            visitorKeys.push('any');
+            visitorKeys.push('ref');
+        }
+        else {
+            if (visitor.any) {
+                throw new Error('any() is allowed only on top level');
+            }
+            if (visitor.ref) {
+                throw new Error('ref() is allowed only on top level');
+            }
+        }
+        for (const typeName of visitorKeys) {
+            const typeVisitor = visitor[typeName];
+            const normalizedTypeVisitor = normalizedVisitors[typeName];
+            if (!typeVisitor)
+                continue;
+            let visitorEnter;
+            let visitorLeave;
+            let visitorSkip;
+            const isObjectVisitor = typeof typeVisitor === 'object';
+            if (typeName === 'ref' && isObjectVisitor && typeVisitor.skip) {
+                throw new Error('ref() visitor does not support skip');
+            }
+            if (typeof typeVisitor === 'function') {
+                visitorEnter = typeVisitor;
+            }
+            else if (isObjectVisitor) {
+                visitorEnter = typeVisitor.enter;
+                visitorLeave = typeVisitor.leave;
+                visitorSkip = typeVisitor.skip;
+            }
+            const context = {
+                activatedOn: null,
+                type: types[typeName],
+                parent: parentContext,
+                isSkippedLevel: false,
+            };
+            if (typeof typeVisitor === 'object') {
+                normalizeVisitorLevel(ruleConf, typeVisitor, context, depth + 1);
+            }
+            if (parentContext) {
+                addWeakNodes(ruleConf, parentContext.type, types[typeName], parentContext);
+            }
+            if (visitorEnter || isObjectVisitor) {
+                if (visitorEnter && typeof visitorEnter !== 'function') {
+                    throw new Error('DEV: should be function');
+                }
+                normalizedTypeVisitor.enter.push(Object.assign(Object.assign({}, ruleConf), { visit: visitorEnter || (() => undefined), skip: visitorSkip, depth,
+                    context }));
+            }
+            if (visitorLeave) {
+                if (typeof visitorLeave !== 'function') {
+                    throw new Error('DEV: should be function');
+                }
+                normalizedTypeVisitor.leave.push(Object.assign(Object.assign({}, ruleConf), { visit: visitorLeave, depth,
+                    context }));
+            }
+        }
+    }
+}
+exports.normalizeVisitors = normalizeVisitors;

package/lib/walk.d.ts

@@ -0,0 +1,87 @@
+import { Referenced } from './typings/openapi';
+import { Location } from './ref-utils';
+import { NormalizedOasVisitors } from './visitors';
+import { ResolvedRefMap, Document, ResolveError, YamlParseError, Source } from './resolve';
+import { OasVersion } from './oas-types';
+import { NormalizedNodeType } from './types';
+declare type NonUndefined = string | number | boolean | symbol | bigint | object | Record<string, any>;
+export declare type ResolveResult<T extends NonUndefined> = {
+    node: T;
+    location: Location;
+    error?: ResolveError | YamlParseError;
+} | {
+    node: undefined;
+    location: undefined;
+    error?: ResolveError | YamlParseError;
+};
+export declare type ResolveFn<T> = (node: Referenced<T>, from?: string) => {
+    location: Location;
+    node: T;
+} | {
+    location: undefined;
+    node: undefined;
+};
+export declare type UserContext = {
+    report(problem: Problem): void;
+    location: Location;
+    resolve<T>(node: Referenced<T>): {
+        location: Location;
+        node: T;
+    } | {
+        location: undefined;
+        node: undefined;
+    };
+    parentLocations: Record<string, Location>;
+    type: NormalizedNodeType;
+    key: string | number;
+    parent: any;
+    oasVersion: OasVersion;
+    getVisitorData: () => Record<string, unknown>;
+};
+export declare type Loc = {
+    line: number;
+    col: number;
+};
+export declare type PointerLocationObject = {
+    source: Source;
+    reportOnKey?: boolean;
+    pointer: string;
+};
+export declare type LineColLocationObject = Omit<PointerLocationObject, 'pointer'> & {
+    pointer: undefined;
+    start: Loc;
+    end?: Loc;
+};
+export declare type LocationObject = LineColLocationObject | PointerLocationObject;
+export declare type ProblemSeverity = 'error' | 'warn';
+export declare type Problem = {
+    message: string;
+    suggest?: string[];
+    location?: Partial<LocationObject> | Array<Partial<LocationObject>>;
+    from?: LocationObject;
+    forceSeverity?: ProblemSeverity;
+    ruleId?: string;
+};
+export declare type NormalizedProblem = {
+    message: string;
+    ruleId: string;
+    severity: ProblemSeverity;
+    location: LocationObject[];
+    from?: LocationObject;
+    suggest: string[];
+    ignored?: boolean;
+};
+export declare type WalkContext = {
+    problems: NormalizedProblem[];
+    oasVersion: OasVersion;
+    visitorsData: Record<string, Record<string, unknown>>;
+    refTypes?: Map<string, NormalizedNodeType>;
+};
+export declare function walkDocument<T>(opts: {
+    document: Document;
+    rootType: NormalizedNodeType;
+    normalizedVisitors: NormalizedOasVisitors<T>;
+    resolvedRefMap: ResolvedRefMap;
+    ctx: WalkContext;
+}): void;
+export {};