@redocly/openapi-core 1.0.0-beta.100

package/lib/format/codeframes.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAstNodeByPointer = exports.getLineColLocation = exports.getCodeframe = void 0;
+const colorette_1 = require("colorette");
+const yamlAst = require("yaml-ast-parser");
+const ref_utils_1 = require("../ref-utils");
+const MAX_LINE_LENGTH = 150;
+const MAX_CODEFRAME_LINES = 3;
+// TODO: temporary
+function parsePointer(pointer) {
+    return pointer.substr(2).split('/').map(ref_utils_1.unescapePointer);
+}
+function getCodeframe(location, color) {
+    colorette_1.options.enabled = color;
+    const { start, end = { line: start.line, col: start.col + 1 }, source } = location;
+    const lines = source.getLines();
+    const startLineNum = start.line;
+    const endLineNum = Math.max(Math.min(end.line, lines.length), start.line);
+    let skipLines = Math.max(endLineNum - startLineNum - MAX_CODEFRAME_LINES + 1, 0);
+    if (skipLines < 2)
+        skipLines = 0; // do not skip one line
+    // Lines specified like this: ["prefix", "string"],
+    const prefixedLines = [];
+    let currentPad = 0;
+    for (let i = startLineNum; i <= endLineNum; i++) {
+        if (skipLines > 0 && i >= endLineNum - skipLines)
+            break;
+        const line = lines[i - 1] || '';
+        if (line !== '')
+            currentPad = padSize(line);
+        let startIdx = i === startLineNum ? start.col - 1 : currentPad;
+        let endIdx = i === endLineNum ? end.col - 1 : line.length;
+        prefixedLines.push([`${i}`, markLine(line, startIdx, endIdx, colorette_1.red)]);
+        if (!color)
+            prefixedLines.push(['', underlineLine(line, startIdx, endIdx)]);
+    }
+    if (skipLines > 0) {
+        prefixedLines.push([`…`, `${whitespace(currentPad)}${colorette_1.gray(`< ${skipLines} more lines >`)}`]);
+        // print last line
+        prefixedLines.push([`${endLineNum}`, markLine(lines[endLineNum - 1], -1, end.col - 1, colorette_1.red)]);
+        if (!color)
+            prefixedLines.push(['', underlineLine(lines[endLineNum - 1], -1, end.col - 1)]);
+    }
+    return printPrefixedLines([
+        [`${startLineNum - 2}`, markLine(lines[startLineNum - 1 - 2])],
+        [`${startLineNum - 1}`, markLine(lines[startLineNum - 1 - 1])],
+        ...prefixedLines,
+        [`${endLineNum + 1}`, markLine(lines[endLineNum - 1 + 1])],
+        [`${endLineNum + 2}`, markLine(lines[endLineNum - 1 + 2])],
+    ]);
+    function markLine(line, startIdx = -1, endIdx = +Infinity, variant = colorette_1.gray) {
+        if (!color)
+            return line;
+        if (!line)
+            return line;
+        if (startIdx === -1) {
+            startIdx = padSize(line);
+        }
+        endIdx = Math.min(endIdx, line.length);
+        return (line.substr(0, startIdx) + variant(line.substring(startIdx, endIdx)) + line.substr(endIdx));
+    }
+}
+exports.getCodeframe = getCodeframe;
+function printPrefixedLines(lines) {
+    const existingLines = lines.filter(([_, line]) => line !== undefined);
+    const padLen = Math.max(...existingLines.map(([prefix]) => prefix.length));
+    const dedentLen = Math.min(...existingLines.map(([_, line]) => (line === '' ? Infinity : padSize(line))));
+    return existingLines
+        .map(([prefix, line]) => colorette_1.gray(leftPad(padLen, prefix) + ' |') +
+        (line ? ' ' + limitLineLength(line.substring(dedentLen)) : ''))
+        .join('\n');
+}
+function limitLineLength(line, maxLen = MAX_LINE_LENGTH) {
+    const overflowLen = line.length - maxLen;
+    if (overflowLen > 0) {
+        const charsMoreText = colorette_1.gray(`...<${overflowLen} chars>`);
+        return line.substring(0, maxLen - charsMoreText.length) + charsMoreText;
+    }
+    else {
+        return line;
+    }
+}
+function underlineLine(line, startIdx = -1, endIdx = +Infinity) {
+    if (startIdx === -1) {
+        startIdx = padSize(line);
+    }
+    endIdx = Math.min(endIdx, line.length);
+    return whitespace(startIdx) + '^'.repeat(Math.max(endIdx - startIdx, 1));
+}
+function whitespace(len) {
+    return ' '.repeat(len);
+}
+function leftPad(len, str) {
+    return whitespace(len - str.length) + str;
+}
+function padSize(line) {
+    for (let i = 0; i < line.length; i++) {
+        if (line[i] !== ' ')
+            return i;
+    }
+    return line.length;
+}
+function getLineColLocation(location) {
+    var _a, _b;
+    if (location.pointer === undefined)
+        return location;
+    const { source, pointer, reportOnKey } = location;
+    const ast = source.getAst(yamlAst.safeLoad);
+    const astNode = getAstNodeByPointer(ast, pointer, !!reportOnKey);
+    return Object.assign(Object.assign(Object.assign({}, location), { pointer: undefined }), positionsToLoc(source.body, (_a = astNode === null || astNode === void 0 ? void 0 : astNode.startPosition) !== null && _a !== void 0 ? _a : 1, (_b = astNode === null || astNode === void 0 ? void 0 : astNode.endPosition) !== null && _b !== void 0 ? _b : 1));
+}
+exports.getLineColLocation = getLineColLocation;
+function positionsToLoc(source, startPos, endPos) {
+    let currentLine = 1;
+    let currentCol = 1;
+    let start = { line: 1, col: 1 };
+    for (let i = 0; i < endPos - 1; i++) {
+        if (i === startPos - 1) {
+            start = { line: currentLine, col: currentCol + 1 };
+        }
+        if (source[i] === '\n') {
+            currentLine++;
+            currentCol = 1;
+            if (i === startPos - 1) {
+                start = { line: currentLine, col: currentCol };
+            }
+            if (source[i + 1] === '\r')
+                i++; // TODO: test it
+            continue;
+        }
+        currentCol++;
+    }
+    const end = startPos === endPos ? Object.assign({}, start) : { line: currentLine, col: currentCol + 1 };
+    return { start, end };
+}
+function getAstNodeByPointer(root, pointer, reportOnKey) {
+    const pointerSegments = parsePointer(pointer);
+    if (root === undefined) {
+        return undefined;
+    }
+    let currentNode = root;
+    for (const key of pointerSegments) {
+        if (currentNode.kind === yamlAst.Kind.MAP) {
+            const mapping = currentNode.mappings.find((m) => m.key.value === key);
+            if (!mapping)
+                break;
+            currentNode = mapping;
+            if (!(mapping === null || mapping === void 0 ? void 0 : mapping.value))
+                break; // If node has value - return value, if not - return node itself
+            currentNode = mapping.value;
+        }
+        else if (currentNode.kind === yamlAst.Kind.SEQ) {
+            const elem = currentNode.items[parseInt(key, 10)];
+            if (!elem)
+                break;
+            currentNode = elem;
+        }
+    }
+    if (!reportOnKey) {
+        return currentNode;
+    }
+    else {
+        const parent = currentNode.parent;
+        if (!parent)
+            return currentNode;
+        if (parent.kind === yamlAst.Kind.SEQ) {
+            return currentNode;
+        }
+        else if (parent.kind === yamlAst.Kind.MAPPING) {
+            return parent.key;
+        }
+        else {
+            return currentNode;
+        }
+    }
+}
+exports.getAstNodeByPointer = getAstNodeByPointer;

package/lib/format/format.d.ts

@@ -0,0 +1,20 @@
+import { NormalizedProblem } from '../walk';
+export declare type Totals = {
+    errors: number;
+    warnings: number;
+    ignored: number;
+};
+export declare type OutputFormat = 'codeframe' | 'stylish' | 'json' | 'checkstyle' | 'codeclimate';
+export declare function getTotals(problems: (NormalizedProblem & {
+    ignored?: boolean;
+})[]): Totals;
+export declare function formatProblems(problems: (NormalizedProblem & {
+    ignored?: boolean;
+})[], opts: {
+    maxProblems?: number;
+    cwd?: string;
+    format?: OutputFormat;
+    color?: boolean;
+    totals: Totals;
+    version: string;
+}): void;

package/lib/format/format.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatProblems = exports.getTotals = void 0;
+const path = require("path");
+const colorette_1 = require("colorette");
+const coreVersion = require('../../package.json').version;
+const codeframes_1 = require("./codeframes");
+const config_1 = require("../config");
+const ERROR_MESSAGE = {
+    INVALID_SEVERITY_LEVEL: 'Invalid severity level; accepted values: error or warn',
+};
+const BG_COLORS = {
+    warn: (str) => colorette_1.bgYellow(colorette_1.black(str)),
+    error: colorette_1.bgRed,
+};
+const COLORS = {
+    warn: colorette_1.yellow,
+    error: colorette_1.red,
+};
+const SEVERITY_NAMES = {
+    warn: 'Warning',
+    error: 'Error',
+};
+const CODECLIMATE_SEVERITY_MAPPING = {
+    error: 'critical',
+    warn: 'minor',
+};
+const MAX_SUGGEST = 5;
+function severityToNumber(severity) {
+    return severity === 'error' ? 1 : 2;
+}
+function getTotals(problems) {
+    let errors = 0;
+    let warnings = 0;
+    let ignored = 0;
+    for (const m of problems) {
+        if (m.ignored) {
+            ignored++;
+            continue;
+        }
+        if (m.severity === 'error')
+            errors++;
+        if (m.severity === 'warn')
+            warnings++;
+    }
+    return {
+        errors,
+        warnings,
+        ignored,
+    };
+}
+exports.getTotals = getTotals;
+function formatProblems(problems, opts) {
+    const { maxProblems = 100, cwd = process.cwd(), format = 'codeframe', color = colorette_1.options.enabled, totals = getTotals(problems), version = coreVersion, } = opts;
+    colorette_1.options.enabled = color; // force colors if specified
+    const totalProblems = problems.length;
+    problems = problems.filter((m) => !m.ignored);
+    const ignoredProblems = totalProblems - problems.length;
+    problems = problems
+        .sort((a, b) => severityToNumber(a.severity) - severityToNumber(b.severity))
+        .slice(0, maxProblems);
+    if (!totalProblems && format !== 'json')
+        return;
+    switch (format) {
+        case 'json':
+            outputJSON();
+            break;
+        case 'codeframe':
+            for (let i = 0; i < problems.length; i++) {
+                const problem = problems[i];
+                process.stderr.write(`${formatCodeframe(problem, i)}\n`);
+            }
+            break;
+        case 'stylish': {
+            const groupedByFile = groupByFiles(problems);
+            for (const [file, { ruleIdPad, locationPad: positionPad, fileProblems }] of Object.entries(groupedByFile)) {
+                process.stderr.write(`${colorette_1.blue(path.relative(cwd, file))}:\n`);
+                for (let i = 0; i < fileProblems.length; i++) {
+                    const problem = fileProblems[i];
+                    process.stderr.write(`${formatStylish(problem, positionPad, ruleIdPad)}\n`);
+                }
+                process.stderr.write('\n');
+            }
+            break;
+        }
+        case 'checkstyle': {
+            const groupedByFile = groupByFiles(problems);
+            process.stdout.write('<?xml version="1.0" encoding="UTF-8"?>\n');
+            process.stdout.write('<checkstyle version="4.3">\n');
+            for (const [file, { fileProblems }] of Object.entries(groupedByFile)) {
+                process.stdout.write(`<file name="${xmlEscape(path.relative(cwd, file))}">\n`);
+                fileProblems.forEach(formatCheckstyle);
+                process.stdout.write(`</file>\n`);
+            }
+            process.stdout.write(`</checkstyle>\n`);
+            break;
+        }
+        case 'codeclimate':
+            outputForCodeClimate();
+            break;
+    }
+    if (totalProblems - ignoredProblems > maxProblems) {
+        process.stderr.write(`< ... ${totalProblems - maxProblems} more problems hidden > ${colorette_1.gray('increase with `--max-problems N`')}\n`);
+    }
+    function outputForCodeClimate() {
+        const issues = problems.map((p) => {
+            const location = p.location[0]; // TODO: support multiple location
+            const lineCol = codeframes_1.getLineColLocation(location);
+            return {
+                description: p.message,
+                location: {
+                    path: path.relative(cwd, location.source.absoluteRef),
+                    lines: {
+                        begin: lineCol.start.line,
+                    },
+                },
+                severity: CODECLIMATE_SEVERITY_MAPPING[p.severity],
+                fingerprint: `${p.ruleId}${p.location.length > 0 ? '-' + p.location[0].pointer : ''}`,
+            };
+        });
+        process.stdout.write(JSON.stringify(issues, null, 2));
+    }
+    function outputJSON() {
+        const resultObject = {
+            totals,
+            version,
+            problems: problems.map((p) => {
+                var _a;
+                let problem = Object.assign(Object.assign({}, p), { location: p.location.map((location) => (Object.assign(Object.assign({}, location), { source: {
+                            ref: path.relative(cwd, location.source.absoluteRef),
+                        } }))), from: p.from
+                        ? Object.assign(Object.assign({}, p.from), { source: {
+                                ref: path.relative(cwd, ((_a = p.from) === null || _a === void 0 ? void 0 : _a.source.absoluteRef) || cwd),
+                            } }) : undefined });
+                if (config_1.env.FORMAT_JSON_WITH_CODEFRAMES) {
+                    const location = p.location[0]; // TODO: support multiple locations
+                    const loc = codeframes_1.getLineColLocation(location);
+                    problem.codeframe = codeframes_1.getCodeframe(loc, color);
+                }
+                return problem;
+            }),
+        };
+        process.stdout.write(JSON.stringify(resultObject, null, 2));
+    }
+    function getBgColor(problem) {
+        const { severity } = problem;
+        if (!BG_COLORS[severity]) {
+            throw new Error(ERROR_MESSAGE.INVALID_SEVERITY_LEVEL);
+        }
+        return BG_COLORS[severity];
+    }
+    function formatCodeframe(problem, idx) {
+        const bgColor = getBgColor(problem);
+        const location = problem.location[0]; // TODO: support multiple locations
+        const relativePath = path.relative(cwd, location.source.absoluteRef);
+        const loc = codeframes_1.getLineColLocation(location);
+        const atPointer = location.pointer ? colorette_1.gray(`at ${location.pointer}`) : '';
+        const fileWithLoc = `${relativePath}:${loc.start.line}:${loc.start.col}`;
+        return (`[${idx + 1}] ${bgColor(fileWithLoc)} ${atPointer}\n\n` +
+            `${problem.message}\n\n` +
+            formatDidYouMean(problem) +
+            codeframes_1.getCodeframe(loc, color) +
+            '\n\n' +
+            formatFrom(cwd, problem.from) +
+            `${SEVERITY_NAMES[problem.severity]} was generated by the ${colorette_1.blue(problem.ruleId)} rule.\n\n`);
+    }
+    function formatStylish(problem, locationPad, ruleIdPad) {
+        const color = COLORS[problem.severity];
+        if (!SEVERITY_NAMES[problem.severity]) {
+            return 'Error not found severity. Please check your config file. Allowed values: \`warn,error,off\`';
+        }
+        const severityName = color(SEVERITY_NAMES[problem.severity].toLowerCase().padEnd(7));
+        const { start } = problem.location[0];
+        return `  ${`${start.line}:${start.col}`.padEnd(locationPad)}  ${severityName}  ${problem.ruleId.padEnd(ruleIdPad)}  ${problem.message}`;
+    }
+    function formatCheckstyle(problem) {
+        const { line, col } = problem.location[0].start;
+        const severity = problem.severity == 'warn' ? 'warning' : 'error';
+        const message = xmlEscape(problem.message);
+        const source = xmlEscape(problem.ruleId);
+        process.stdout.write(`<error line="${line}" column="${col}" severity="${severity}" message="${message}" source="${source}" />\n`);
+    }
+}
+exports.formatProblems = formatProblems;
+function formatFrom(cwd, location) {
+    if (!location)
+        return '';
+    const relativePath = path.relative(cwd, location.source.absoluteRef);
+    const loc = codeframes_1.getLineColLocation(location);
+    const fileWithLoc = `${relativePath}:${loc.start.line}:${loc.start.col}`;
+    return `referenced from ${colorette_1.blue(fileWithLoc)}\n\n`;
+}
+function formatDidYouMean(problem) {
+    if (problem.suggest.length === 0)
+        return '';
+    if (problem.suggest.length === 1) {
+        return `Did you mean: ${problem.suggest[0]} ?\n\n`;
+    }
+    else {
+        return `Did you mean:\n  - ${problem.suggest.slice(0, MAX_SUGGEST).join('\n  - ')}\n\n`;
+    }
+}
+const groupByFiles = (problems) => {
+    const fileGroups = {};
+    for (const problem of problems) {
+        const absoluteRef = problem.location[0].source.absoluteRef; // TODO: multiple errors
+        fileGroups[absoluteRef] = fileGroups[absoluteRef] || {
+            fileProblems: [],
+            ruleIdPad: 0,
+            locationPad: 0,
+        };
+        const mappedProblem = Object.assign(Object.assign({}, problem), { location: problem.location.map(codeframes_1.getLineColLocation) });
+        fileGroups[absoluteRef].fileProblems.push(mappedProblem);
+        fileGroups[absoluteRef].ruleIdPad = Math.max(problem.ruleId.length, fileGroups[absoluteRef].ruleIdPad);
+        fileGroups[absoluteRef].locationPad = Math.max(Math.max(...mappedProblem.location.map((loc) => `${loc.start.line}:${loc.start.col}`.length)), fileGroups[absoluteRef].locationPad);
+    }
+    return fileGroups;
+};
+function xmlEscape(s) {
+    return s.replace(/[<>&"'\x00-\x1F\x7F\u0080-\uFFFF]/gu, (char) => {
+        switch (char) {
+            case '<':
+                return '&lt;';
+            case '>':
+                return '&gt;';
+            case '&':
+                return '&amp;';
+            case '"':
+                return '&quot;';
+            case "'":
+                return '&apos;';
+            default:
+                return `&#${char.charCodeAt(0)};`;
+        }
+    });
+}

package/lib/index.d.ts

@@ -0,0 +1,22 @@
+export { BundleOutputFormat, readFileFromUrl, slash } from './utils';
+export { Oas3_1Types } from './types/oas3_1';
+export { Oas3Types } from './types/oas3';
+export { Oas2Types } from './types/oas2';
+export { ConfigTypes } from './types/redocly-yaml';
+export { Oas3Definition, Oas3_1Definition, Oas3Components, Oas3PathItem, Oas3Paths, Oas3ComponentName, Oas3Schema, Oas3_1Schema, Oas3Tag, Oas3_1Webhooks, Referenced, } from './typings/openapi';
+export { Oas2Definition } from './typings/swagger';
+export { StatsAccumulator, StatsName } from './typings/common';
+export { normalizeTypes } from './types';
+export { Stats } from './rules/other/stats';
+export { Config, LintConfig, RawConfig, IGNORE_FILE, Region, getMergedConfig, transformConfig, loadConfig, getConfig, findConfig, CONFIG_FILE_NAMES, } from './config';
+export { RedoclyClient, isRedoclyRegistryURL } from './redocly';
+export { Source, BaseResolver, Document, resolveDocument, ResolveError, YamlParseError, makeDocumentFromString, } from './resolve';
+export { parseYaml, stringifyYaml } from './js-yaml';
+export { unescapePointer, isRef } from './ref-utils';
+export { detectOpenAPI, OasMajorVersion, openAPIMajor, OasVersion } from './oas-types';
+export { normalizeVisitors } from './visitors';
+export { WalkContext, walkDocument, NormalizedProblem, ProblemSeverity, LineColLocationObject, LocationObject, Loc, } from './walk';
+export { getAstNodeByPointer, getLineColLocation } from './format/codeframes';
+export { formatProblems, OutputFormat, getTotals, Totals } from './format/format';
+export { lint, lint as validate, lintDocument, lintFromString, lintConfig } from './lint';
+export { bundle, bundleDocument, mapTypeToComponent } from './bundle';

package/lib/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapTypeToComponent = exports.bundleDocument = exports.bundle = exports.lintConfig = exports.lintFromString = exports.lintDocument = exports.validate = exports.lint = exports.getTotals = exports.formatProblems = exports.getLineColLocation = exports.getAstNodeByPointer = exports.walkDocument = exports.normalizeVisitors = exports.OasVersion = exports.openAPIMajor = exports.OasMajorVersion = exports.detectOpenAPI = exports.isRef = exports.unescapePointer = exports.stringifyYaml = exports.parseYaml = exports.makeDocumentFromString = exports.YamlParseError = exports.ResolveError = exports.resolveDocument = exports.BaseResolver = exports.Source = exports.isRedoclyRegistryURL = exports.RedoclyClient = exports.CONFIG_FILE_NAMES = exports.findConfig = exports.getConfig = exports.loadConfig = exports.transformConfig = exports.getMergedConfig = exports.IGNORE_FILE = exports.LintConfig = exports.Config = exports.Stats = exports.normalizeTypes = exports.ConfigTypes = exports.Oas2Types = exports.Oas3Types = exports.Oas3_1Types = exports.slash = exports.readFileFromUrl = void 0;
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "readFileFromUrl", { enumerable: true, get: function () { return utils_1.readFileFromUrl; } });
+Object.defineProperty(exports, "slash", { enumerable: true, get: function () { return utils_1.slash; } });
+var oas3_1_1 = require("./types/oas3_1");
+Object.defineProperty(exports, "Oas3_1Types", { enumerable: true, get: function () { return oas3_1_1.Oas3_1Types; } });
+var oas3_1 = require("./types/oas3");
+Object.defineProperty(exports, "Oas3Types", { enumerable: true, get: function () { return oas3_1.Oas3Types; } });
+var oas2_1 = require("./types/oas2");
+Object.defineProperty(exports, "Oas2Types", { enumerable: true, get: function () { return oas2_1.Oas2Types; } });
+var redocly_yaml_1 = require("./types/redocly-yaml");
+Object.defineProperty(exports, "ConfigTypes", { enumerable: true, get: function () { return redocly_yaml_1.ConfigTypes; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "normalizeTypes", { enumerable: true, get: function () { return types_1.normalizeTypes; } });
+var stats_1 = require("./rules/other/stats");
+Object.defineProperty(exports, "Stats", { enumerable: true, get: function () { return stats_1.Stats; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
+Object.defineProperty(exports, "LintConfig", { enumerable: true, get: function () { return config_1.LintConfig; } });
+Object.defineProperty(exports, "IGNORE_FILE", { enumerable: true, get: function () { return config_1.IGNORE_FILE; } });
+Object.defineProperty(exports, "getMergedConfig", { enumerable: true, get: function () { return config_1.getMergedConfig; } });
+Object.defineProperty(exports, "transformConfig", { enumerable: true, get: function () { return config_1.transformConfig; } });
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_1.getConfig; } });
+Object.defineProperty(exports, "findConfig", { enumerable: true, get: function () { return config_1.findConfig; } });
+Object.defineProperty(exports, "CONFIG_FILE_NAMES", { enumerable: true, get: function () { return config_1.CONFIG_FILE_NAMES; } });
+var redocly_1 = require("./redocly");
+Object.defineProperty(exports, "RedoclyClient", { enumerable: true, get: function () { return redocly_1.RedoclyClient; } });
+Object.defineProperty(exports, "isRedoclyRegistryURL", { enumerable: true, get: function () { return redocly_1.isRedoclyRegistryURL; } });
+var resolve_1 = require("./resolve");
+Object.defineProperty(exports, "Source", { enumerable: true, get: function () { return resolve_1.Source; } });
+Object.defineProperty(exports, "BaseResolver", { enumerable: true, get: function () { return resolve_1.BaseResolver; } });
+Object.defineProperty(exports, "resolveDocument", { enumerable: true, get: function () { return resolve_1.resolveDocument; } });
+Object.defineProperty(exports, "ResolveError", { enumerable: true, get: function () { return resolve_1.ResolveError; } });
+Object.defineProperty(exports, "YamlParseError", { enumerable: true, get: function () { return resolve_1.YamlParseError; } });
+Object.defineProperty(exports, "makeDocumentFromString", { enumerable: true, get: function () { return resolve_1.makeDocumentFromString; } });
+var js_yaml_1 = require("./js-yaml");
+Object.defineProperty(exports, "parseYaml", { enumerable: true, get: function () { return js_yaml_1.parseYaml; } });
+Object.defineProperty(exports, "stringifyYaml", { enumerable: true, get: function () { return js_yaml_1.stringifyYaml; } });
+var ref_utils_1 = require("./ref-utils");
+Object.defineProperty(exports, "unescapePointer", { enumerable: true, get: function () { return ref_utils_1.unescapePointer; } });
+Object.defineProperty(exports, "isRef", { enumerable: true, get: function () { return ref_utils_1.isRef; } });
+var oas_types_1 = require("./oas-types");
+Object.defineProperty(exports, "detectOpenAPI", { enumerable: true, get: function () { return oas_types_1.detectOpenAPI; } });
+Object.defineProperty(exports, "OasMajorVersion", { enumerable: true, get: function () { return oas_types_1.OasMajorVersion; } });
+Object.defineProperty(exports, "openAPIMajor", { enumerable: true, get: function () { return oas_types_1.openAPIMajor; } });
+Object.defineProperty(exports, "OasVersion", { enumerable: true, get: function () { return oas_types_1.OasVersion; } });
+var visitors_1 = require("./visitors");
+Object.defineProperty(exports, "normalizeVisitors", { enumerable: true, get: function () { return visitors_1.normalizeVisitors; } });
+var walk_1 = require("./walk");
+Object.defineProperty(exports, "walkDocument", { enumerable: true, get: function () { return walk_1.walkDocument; } });
+var codeframes_1 = require("./format/codeframes");
+Object.defineProperty(exports, "getAstNodeByPointer", { enumerable: true, get: function () { return codeframes_1.getAstNodeByPointer; } });
+Object.defineProperty(exports, "getLineColLocation", { enumerable: true, get: function () { return codeframes_1.getLineColLocation; } });
+var format_1 = require("./format/format");
+Object.defineProperty(exports, "formatProblems", { enumerable: true, get: function () { return format_1.formatProblems; } });
+Object.defineProperty(exports, "getTotals", { enumerable: true, get: function () { return format_1.getTotals; } });
+var lint_1 = require("./lint");
+Object.defineProperty(exports, "lint", { enumerable: true, get: function () { return lint_1.lint; } });
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return lint_1.lint; } });
+Object.defineProperty(exports, "lintDocument", { enumerable: true, get: function () { return lint_1.lintDocument; } });
+Object.defineProperty(exports, "lintFromString", { enumerable: true, get: function () { return lint_1.lintFromString; } });
+Object.defineProperty(exports, "lintConfig", { enumerable: true, get: function () { return lint_1.lintConfig; } });
+var bundle_1 = require("./bundle");
+Object.defineProperty(exports, "bundle", { enumerable: true, get: function () { return bundle_1.bundle; } });
+Object.defineProperty(exports, "bundleDocument", { enumerable: true, get: function () { return bundle_1.bundleDocument; } });
+Object.defineProperty(exports, "mapTypeToComponent", { enumerable: true, get: function () { return bundle_1.mapTypeToComponent; } });

package/lib/js-yaml/index.d.ts

@@ -0,0 +1,3 @@
+import { LoadOptions, DumpOptions } from 'js-yaml';
+export declare const parseYaml: (str: string, opts?: LoadOptions | undefined) => unknown;
+export declare const stringifyYaml: (obj: any, opts?: DumpOptions | undefined) => string;

package/lib/js-yaml/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyYaml = exports.parseYaml = void 0;
+// TODO: add a type for "types" https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/js-yaml/index.d.ts
+// @ts-ignore
+const js_yaml_1 = require("js-yaml");
+const DEFAULT_SCHEMA_WITHOUT_TIMESTAMP = js_yaml_1.JSON_SCHEMA.extend({
+    implicit: [js_yaml_1.types.merge],
+    explicit: [
+        js_yaml_1.types.binary,
+        js_yaml_1.types.omap,
+        js_yaml_1.types.pairs,
+        js_yaml_1.types.set,
+    ],
+});
+const parseYaml = (str, opts) => js_yaml_1.load(str, Object.assign({ schema: DEFAULT_SCHEMA_WITHOUT_TIMESTAMP }, opts));
+exports.parseYaml = parseYaml;
+const stringifyYaml = (obj, opts) => js_yaml_1.dump(obj, opts);
+exports.stringifyYaml = stringifyYaml;

package/lib/lint.d.ts

@@ -0,0 +1,23 @@
+import { BaseResolver, Document } from './resolve';
+import { NodeType } from './types';
+import { LintConfig, Config } from './config';
+export declare function lint(opts: {
+    ref: string;
+    config: Config;
+    externalRefResolver?: BaseResolver;
+}): Promise<import("./walk").NormalizedProblem[]>;
+export declare function lintFromString(opts: {
+    source: string;
+    absoluteRef?: string;
+    config: Config;
+    externalRefResolver?: BaseResolver;
+}): Promise<import("./walk").NormalizedProblem[]>;
+export declare function lintDocument(opts: {
+    document: Document;
+    config: LintConfig;
+    customTypes?: Record<string, NodeType>;
+    externalRefResolver: BaseResolver;
+}): Promise<import("./walk").NormalizedProblem[]>;
+export declare function lintConfig(opts: {
+    document: Document;
+}): Promise<import("./walk").NormalizedProblem[]>;