@redocly/openapi-core 1.18.1 → 1.20.0

package/lib/resolve.js

@@ -1,15 +1,9 @@
 "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.resolveDocument = exports.BaseResolver = exports.makeDocumentFromString = exports.makeRefId = exports.YamlParseError = exports.ResolveError = exports.Source = void 0;
+exports.BaseResolver = exports.YamlParseError = exports.ResolveError = exports.Source = void 0;
+exports.makeRefId = makeRefId;
+exports.makeDocumentFromString = makeDocumentFromString;
+exports.resolveDocument = resolveDocument;
 const fs = require("fs");
 const path = require("path");
 const ref_utils_1 = require("./ref-utils");
@@ -23,9 +17,8 @@ class Source {
     }
     // pass safeLoad as argument to separate it from browser bundle
     getAst(safeLoad) {
-        var _a;
         if (this._ast === undefined) {
-            this._ast = (_a = safeLoad(this.body, { filename: this.absoluteRef })) !== null && _a !== void 0 ? _a : undefined;
+            this._ast = safeLoad(this.body, { filename: this.absoluteRef }) ?? undefined;
             // fix ast representation of file with newlines only
             if (this._ast &&
                 this._ast.kind === 0 && // KIND.scalar = 0
@@ -71,7 +64,6 @@ exports.YamlParseError = YamlParseError;
 function makeRefId(absoluteRef, pointer) {
     return absoluteRef + '::' + pointer;
 }
-exports.makeRefId = makeRefId;
 function makeDocumentFromString(sourceString, absoluteRef) {
     const source = new Source(absoluteRef, sourceString);
     try {
@@ -84,7 +76,6 @@ function makeDocumentFromString(sourceString, absoluteRef) {
         throw new YamlParseError(e, source);
     }
 }
-exports.makeDocumentFromString = makeDocumentFromString;
 class BaseResolver {
     constructor(config = { http: { headers: [] } }) {
         this.config = config;
@@ -102,33 +93,30 @@ class BaseResolver {
         }
         return path.resolve(base ? path.dirname(base) : process.cwd(), ref);
     }
-    loadExternalRef(absoluteRef) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if ((0, ref_utils_1.isAbsoluteUrl)(absoluteRef)) {
-                    const { body, mimeType } = yield (0, utils_1.readFileFromUrl)(absoluteRef, this.config.http);
-                    return new Source(absoluteRef, body, mimeType);
-                }
-                else {
-                    if (fs.lstatSync(absoluteRef).isDirectory()) {
-                        throw new Error(`Expected a file but received a folder at ${absoluteRef}`);
-                    }
-                    const content = yield fs.promises.readFile(absoluteRef, 'utf-8');
-                    // In some cases file have \r\n line delimeters like on windows, we should skip it.
-                    return new Source(absoluteRef, content.replace(/\r\n/g, '\n'));
-                }
+    async loadExternalRef(absoluteRef) {
+        try {
+            if ((0, ref_utils_1.isAbsoluteUrl)(absoluteRef)) {
+                const { body, mimeType } = await (0, utils_1.readFileFromUrl)(absoluteRef, this.config.http);
+                return new Source(absoluteRef, body, mimeType);
             }
-            catch (error) {
-                error.message = error.message.replace(', lstat', '');
-                throw new ResolveError(error);
+            else {
+                if (fs.lstatSync(absoluteRef).isDirectory()) {
+                    throw new Error(`Expected a file but received a folder at ${absoluteRef}`);
+                }
+                const content = await fs.promises.readFile(absoluteRef, 'utf-8');
+                // In some cases file have \r\n line delimeters like on windows, we should skip it.
+                return new Source(absoluteRef, content.replace(/\r\n/g, '\n'));
             }
-        });
+        }
+        catch (error) {
+            error.message = error.message.replace(', lstat', '');
+            throw new ResolveError(error);
+        }
     }
     parseDocument(source, isRoot = false) {
-        var _a;
         const ext = source.absoluteRef.substr(source.absoluteRef.lastIndexOf('.'));
         if (!['.json', '.json', '.yml', '.yaml'].includes(ext) &&
-            !((_a = source.mimeType) === null || _a === void 0 ? void 0 : _a.match(/(json|yaml|openapi)/)) &&
+            !source.mimeType?.match(/(json|yaml|openapi)/) &&
             !isRoot // always parse root
         ) {
             return { source, parsed: source.body };
@@ -143,19 +131,17 @@ class BaseResolver {
             throw new YamlParseError(e, source);
         }
     }
-    resolveDocument(base, ref, isRoot = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const absoluteRef = this.resolveExternalRef(base, ref);
-            const cachedDocument = this.cache.get(absoluteRef);
-            if (cachedDocument) {
-                return cachedDocument;
-            }
-            const doc = this.loadExternalRef(absoluteRef).then((source) => {
-                return this.parseDocument(source, isRoot);
-            });
-            this.cache.set(absoluteRef, doc);
-            return doc;
+    async resolveDocument(base, ref, isRoot = false) {
+        const absoluteRef = this.resolveExternalRef(base, ref);
+        const cachedDocument = this.cache.get(absoluteRef);
+        if (cachedDocument) {
+            return cachedDocument;
+        }
+        const doc = this.loadExternalRef(absoluteRef).then((source) => {
+            return this.parseDocument(source, isRoot);
         });
+        this.cache.set(absoluteRef, doc);
+        return doc;
     }
 }
 exports.BaseResolver = BaseResolver;
@@ -176,174 +162,169 @@ function hasRef(head, node) {
 }
 const unknownType = { name: 'unknown', properties: {} };
 const resolvableScalarType = { name: 'scalar', properties: {} };
-function resolveDocument(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { rootDocument, externalRefResolver, rootType } = opts;
-        const resolvedRefMap = new Map();
-        const seedNodes = new Set(); // format "${type}::${absoluteRef}${pointer}"
-        const resolvePromises = [];
-        resolveRefsInParallel(rootDocument.parsed, rootDocument, '#/', rootType);
-        let resolved;
-        do {
-            resolved = yield Promise.all(resolvePromises);
-        } while (resolvePromises.length !== resolved.length);
-        return resolvedRefMap;
-        function resolveRefsInParallel(rootNode, rootNodeDocument, rootNodePointer, type) {
-            const rootNodeDocAbsoluteRef = rootNodeDocument.source.absoluteRef;
-            const anchorRefsMap = new Map();
-            walk(rootNode, type, rootNodeDocAbsoluteRef + rootNodePointer);
-            function walk(node, type, nodeAbsoluteRef) {
-                if (typeof node !== 'object' || node === null) {
-                    return;
-                }
-                const nodeId = `${type.name}::${nodeAbsoluteRef}`;
-                if (seedNodes.has(nodeId)) {
+async function resolveDocument(opts) {
+    const { rootDocument, externalRefResolver, rootType } = opts;
+    const resolvedRefMap = new Map();
+    const seedNodes = new Set(); // format "${type}::${absoluteRef}${pointer}"
+    const resolvePromises = [];
+    resolveRefsInParallel(rootDocument.parsed, rootDocument, '#/', rootType);
+    let resolved;
+    do {
+        resolved = await Promise.all(resolvePromises);
+    } while (resolvePromises.length !== resolved.length);
+    return resolvedRefMap;
+    function resolveRefsInParallel(rootNode, rootNodeDocument, rootNodePointer, type) {
+        const rootNodeDocAbsoluteRef = rootNodeDocument.source.absoluteRef;
+        const anchorRefsMap = new Map();
+        walk(rootNode, type, rootNodeDocAbsoluteRef + rootNodePointer);
+        function walk(node, type, nodeAbsoluteRef) {
+            if (typeof node !== 'object' || node === null) {
+                return;
+            }
+            const nodeId = `${type.name}::${nodeAbsoluteRef}`;
+            if (seedNodes.has(nodeId)) {
+                return;
+            }
+            seedNodes.add(nodeId);
+            const [_, anchor] = Object.entries(node).find(([key]) => key === '$anchor') || [];
+            if (anchor) {
+                anchorRefsMap.set(`#${anchor}`, node);
+            }
+            if (Array.isArray(node)) {
+                const itemsType = type.items;
+                // we continue resolving unknown types, but stop early on known scalars
+                if (itemsType === undefined && type !== unknownType && type !== types_1.SpecExtension) {
                     return;
                 }
-                seedNodes.add(nodeId);
-                const [_, anchor] = Object.entries(node).find(([key]) => key === '$anchor') || [];
-                if (anchor) {
-                    anchorRefsMap.set(`#${anchor}`, node);
-                }
-                if (Array.isArray(node)) {
-                    const itemsType = type.items;
+                const isTypeAFunction = typeof itemsType === 'function';
+                for (let i = 0; i < node.length; i++) {
+                    const itemType = isTypeAFunction
+                        ? itemsType(node[i], (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, i))
+                        : itemsType;
                     // we continue resolving unknown types, but stop early on known scalars
-                    if (itemsType === undefined && type !== unknownType && type !== types_1.SpecExtension) {
-                        return;
-                    }
-                    const isTypeAFunction = typeof itemsType === 'function';
-                    for (let i = 0; i < node.length; i++) {
-                        const itemType = isTypeAFunction
-                            ? itemsType(node[i], (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, i))
-                            : itemsType;
-                        // we continue resolving unknown types, but stop early on known scalars
-                        if (itemType === undefined && type !== unknownType && type !== types_1.SpecExtension) {
-                            continue;
-                        }
-                        walk(node[i], (0, types_1.isNamedType)(itemType) ? itemType : unknownType, (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, i));
-                    }
-                    return;
-                }
-                for (const propName of Object.keys(node)) {
-                    let propValue = node[propName];
-                    let propType = type.properties[propName];
-                    if (propType === undefined)
-                        propType = type.additionalProperties;
-                    if (typeof propType === 'function')
-                        propType = propType(propValue, propName);
-                    if (propType === undefined)
-                        propType = unknownType;
-                    if (type.extensionsPrefix &&
-                        propName.startsWith(type.extensionsPrefix) &&
-                        propType === unknownType) {
-                        propType = types_1.SpecExtension;
-                    }
-                    if (!(0, types_1.isNamedType)(propType) && (propType === null || propType === void 0 ? void 0 : propType.directResolveAs)) {
-                        propType = propType.directResolveAs;
-                        propValue = { $ref: propValue };
-                    }
-                    if (propType && propType.name === undefined && propType.resolvable !== false) {
-                        propType = resolvableScalarType;
-                    }
-                    if (!(0, types_1.isNamedType)(propType) || typeof propValue !== 'object') {
+                    if (itemType === undefined && type !== unknownType && type !== types_1.SpecExtension) {
                         continue;
                     }
-                    walk(propValue, propType, (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, (0, ref_utils_1.escapePointer)(propName)));
+                    walk(node[i], (0, types_1.isNamedType)(itemType) ? itemType : unknownType, (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, i));
+                }
+                return;
+            }
+            for (const propName of Object.keys(node)) {
+                let propValue = node[propName];
+                let propType = type.properties[propName];
+                if (propType === undefined)
+                    propType = type.additionalProperties;
+                if (typeof propType === 'function')
+                    propType = propType(propValue, propName);
+                if (propType === undefined)
+                    propType = unknownType;
+                if (type.extensionsPrefix &&
+                    propName.startsWith(type.extensionsPrefix) &&
+                    propType === unknownType) {
+                    propType = types_1.SpecExtension;
                 }
-                if ((0, ref_utils_1.isRef)(node)) {
-                    const promise = followRef(rootNodeDocument, node, {
-                        prev: null,
-                        node,
-                    }).then((resolvedRef) => {
-                        if (resolvedRef.resolved) {
-                            resolveRefsInParallel(resolvedRef.node, resolvedRef.document, resolvedRef.nodePointer, type);
-                        }
-                    });
-                    resolvePromises.push(promise);
+                if (!(0, types_1.isNamedType)(propType) && propType?.directResolveAs) {
+                    propType = propType.directResolveAs;
+                    propValue = { $ref: propValue };
                 }
+                if (propType && propType.name === undefined && propType.resolvable !== false) {
+                    propType = resolvableScalarType;
+                }
+                if (!(0, types_1.isNamedType)(propType) || typeof propValue !== 'object') {
+                    continue;
+                }
+                walk(propValue, propType, (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, (0, ref_utils_1.escapePointer)(propName)));
             }
-            function followRef(document, ref, refStack) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    if (hasRef(refStack.prev, ref)) {
-                        throw new Error('Self-referencing circular pointer');
-                    }
-                    if ((0, ref_utils_1.isAnchor)(ref.$ref)) {
-                        // Wait for all anchors in the document to be collected firstly.
-                        yield (0, utils_1.nextTick)();
-                        const resolvedRef = {
-                            resolved: true,
-                            isRemote: false,
-                            node: anchorRefsMap.get(ref.$ref),
-                            document,
-                            nodePointer: ref.$ref,
-                        };
-                        const refId = makeRefId(document.source.absoluteRef, ref.$ref);
-                        resolvedRefMap.set(refId, resolvedRef);
-                        return resolvedRef;
-                    }
-                    const { uri, pointer } = (0, ref_utils_1.parseRef)(ref.$ref);
-                    const isRemote = uri !== null;
-                    let targetDoc;
-                    try {
-                        targetDoc = isRemote
-                            ? (yield externalRefResolver.resolveDocument(document.source.absoluteRef, uri))
-                            : document;
+            if ((0, ref_utils_1.isRef)(node)) {
+                const promise = followRef(rootNodeDocument, node, {
+                    prev: null,
+                    node,
+                }).then((resolvedRef) => {
+                    if (resolvedRef.resolved) {
+                        resolveRefsInParallel(resolvedRef.node, resolvedRef.document, resolvedRef.nodePointer, type);
                     }
-                    catch (error) {
-                        const resolvedRef = {
-                            resolved: false,
-                            isRemote,
-                            document: undefined,
-                            error: error,
-                        };
-                        const refId = makeRefId(document.source.absoluteRef, ref.$ref);
-                        resolvedRefMap.set(refId, resolvedRef);
-                        return resolvedRef;
-                    }
-                    let resolvedRef = {
-                        resolved: true,
-                        document: targetDoc,
-                        isRemote,
-                        node: document.parsed,
-                        nodePointer: '#/',
-                    };
-                    let target = targetDoc.parsed;
-                    const segments = pointer;
-                    for (const segment of segments) {
-                        if (typeof target !== 'object') {
-                            target = undefined;
-                            break;
-                        }
-                        else if (target[segment] !== undefined) {
-                            target = target[segment];
-                            resolvedRef.nodePointer = (0, ref_utils_1.joinPointer)(resolvedRef.nodePointer, (0, ref_utils_1.escapePointer)(segment));
-                        }
-                        else if ((0, ref_utils_1.isRef)(target)) {
-                            resolvedRef = yield followRef(targetDoc, target, pushRef(refStack, target));
-                            targetDoc = resolvedRef.document || targetDoc;
-                            if (typeof resolvedRef.node !== 'object') {
-                                target = undefined;
-                                break;
-                            }
-                            target = resolvedRef.node[segment];
-                            resolvedRef.nodePointer = (0, ref_utils_1.joinPointer)(resolvedRef.nodePointer, (0, ref_utils_1.escapePointer)(segment));
-                        }
-                        else {
-                            target = undefined;
-                            break;
-                        }
-                    }
-                    resolvedRef.node = target;
-                    resolvedRef.document = targetDoc;
-                    const refId = makeRefId(document.source.absoluteRef, ref.$ref);
-                    if (resolvedRef.document && (0, ref_utils_1.isRef)(target)) {
-                        resolvedRef = yield followRef(resolvedRef.document, target, pushRef(refStack, target));
-                    }
-                    resolvedRefMap.set(refId, resolvedRef);
-                    return Object.assign({}, resolvedRef);
                 });
+                resolvePromises.push(promise);
             }
         }
-    });
+        async function followRef(document, ref, refStack) {
+            if (hasRef(refStack.prev, ref)) {
+                throw new Error('Self-referencing circular pointer');
+            }
+            if ((0, ref_utils_1.isAnchor)(ref.$ref)) {
+                // Wait for all anchors in the document to be collected firstly.
+                await (0, utils_1.nextTick)();
+                const resolvedRef = {
+                    resolved: true,
+                    isRemote: false,
+                    node: anchorRefsMap.get(ref.$ref),
+                    document,
+                    nodePointer: ref.$ref,
+                };
+                const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+                resolvedRefMap.set(refId, resolvedRef);
+                return resolvedRef;
+            }
+            const { uri, pointer } = (0, ref_utils_1.parseRef)(ref.$ref);
+            const isRemote = uri !== null;
+            let targetDoc;
+            try {
+                targetDoc = isRemote
+                    ? (await externalRefResolver.resolveDocument(document.source.absoluteRef, uri))
+                    : document;
+            }
+            catch (error) {
+                const resolvedRef = {
+                    resolved: false,
+                    isRemote,
+                    document: undefined,
+                    error: error,
+                };
+                const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+                resolvedRefMap.set(refId, resolvedRef);
+                return resolvedRef;
+            }
+            let resolvedRef = {
+                resolved: true,
+                document: targetDoc,
+                isRemote,
+                node: document.parsed,
+                nodePointer: '#/',
+            };
+            let target = targetDoc.parsed;
+            const segments = pointer;
+            for (const segment of segments) {
+                if (typeof target !== 'object') {
+                    target = undefined;
+                    break;
+                }
+                else if (target[segment] !== undefined) {
+                    target = target[segment];
+                    resolvedRef.nodePointer = (0, ref_utils_1.joinPointer)(resolvedRef.nodePointer, (0, ref_utils_1.escapePointer)(segment));
+                }
+                else if ((0, ref_utils_1.isRef)(target)) {
+                    resolvedRef = await followRef(targetDoc, target, pushRef(refStack, target));
+                    targetDoc = resolvedRef.document || targetDoc;
+                    if (typeof resolvedRef.node !== 'object') {
+                        target = undefined;
+                        break;
+                    }
+                    target = resolvedRef.node[segment];
+                    resolvedRef.nodePointer = (0, ref_utils_1.joinPointer)(resolvedRef.nodePointer, (0, ref_utils_1.escapePointer)(segment));
+                }
+                else {
+                    target = undefined;
+                    break;
+                }
+            }
+            resolvedRef.node = target;
+            resolvedRef.document = targetDoc;
+            const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+            if (resolvedRef.document && (0, ref_utils_1.isRef)(target)) {
+                resolvedRef = await followRef(resolvedRef.document, target, pushRef(refStack, target));
+            }
+            resolvedRefMap.set(refId, resolvedRef);
+            return { ...resolvedRef };
+        }
+    }
 }
-exports.resolveDocument = resolveDocument;

package/lib/rules/ajv.d.ts

@@ -1,4 +1,4 @@
-import { Location } from '../ref-utils';
+import type { Location } from '../ref-utils';
 import type { ErrorObject } from '@redocly/ajv/dist/2020';
 import type { ResolveFn } from '../walk';
 export declare function releaseAjvInstance(): void;

package/lib/rules/ajv.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateJsonSchema = exports.releaseAjvInstance = void 0;
+exports.releaseAjvInstance = releaseAjvInstance;
+exports.validateJsonSchema = validateJsonSchema;
 const _2020_1 = require("@redocly/ajv/dist/2020");
 const ref_utils_1 = require("../ref-utils");
 let ajvInstance = null;
 function releaseAjvInstance() {
     ajvInstance = null;
 }
-exports.releaseAjvInstance = releaseAjvInstance;
 function getAjv(resolve, allowAdditionalProperties) {
     if (!ajvInstance) {
         ajvInstance = new _2020_1.default({
@@ -19,13 +19,13 @@ function getAjv(resolve, allowAdditionalProperties) {
             validateSchema: false,
             discriminator: true,
             allowUnionTypes: true,
-            validateFormats: false,
+            validateFormats: false, // TODO: fix it
             defaultUnevaluatedProperties: allowAdditionalProperties,
             loadSchemaSync(base, $ref, $id) {
                 const resolvedRef = resolve({ $ref }, base.split('#')[0]);
                 if (!resolvedRef || !resolvedRef.location)
                     return false;
-                return Object.assign({ $id: resolvedRef.location.source.absoluteRef + '#' + $id }, resolvedRef.node);
+                return { $id: resolvedRef.location.source.absoluteRef + '#' + $id, ...resolvedRef.node };
             },
             logger: false,
         });
@@ -35,7 +35,7 @@ function getAjv(resolve, allowAdditionalProperties) {
 function getAjvValidator(schema, loc, resolve, allowAdditionalProperties) {
     const ajv = getAjv(resolve, allowAdditionalProperties);
     if (!ajv.getSchema(loc.absolutePointer)) {
-        ajv.addSchema(Object.assign({ $id: loc.absolutePointer }, schema), loc.absolutePointer);
+        ajv.addSchema({ $id: loc.absolutePointer, ...schema }, loc.absolutePointer);
     }
     return ajv.getSchema(loc.absolutePointer);
 }
@@ -73,8 +73,10 @@ function validateJsonSchema(data, schema, schemaLoc, instancePath, resolve, allo
             message = `${message} \`${property}\``;
             error.instancePath += '/' + (0, ref_utils_1.escapePointer)(property);
         }
-        return Object.assign(Object.assign({}, error), { message,
-            suggest });
+        return {
+            ...error,
+            message,
+            suggest,
+        };
     }
 }
-exports.validateJsonSchema = validateJsonSchema;

package/lib/rules/arazzo/index.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preprocessors = exports.rules = void 0;
 const spec_1 = require("../common/spec");
 const assertions_1 = require("../common/assertions");
+const parameters_no_body_inside_in_1 = require("../spot/parameters-no-body-inside-in");
 exports.rules = {
     spec: spec_1.Spec,
     assertions: assertions_1.Assertions,
+    'parameters-no-body-inside-in': parameters_no_body_inside_in_1.ParametersNoBodyInsideIn,
 };
 exports.preprocessors = {};

package/lib/rules/async2/channels-kebab-case.d.ts

@@ -1,2 +1,2 @@
-import { Async2Rule } from '../../visitors';
+import type { Async2Rule } from '../../visitors';
 export declare const ChannelsKebabCase: Async2Rule;

package/lib/rules/async2/index.js

@@ -4,6 +4,7 @@ exports.preprocessors = exports.rules = void 0;
 const assertions_1 = require("../common/assertions");
 const spec_1 = require("../common/spec");
 const info_contact_1 = require("../common/info-contact");
+const info_license_strict_1 = require("../common/info-license-strict");
 const operation_operationId_1 = require("../common/operation-operationId");
 const tag_description_1 = require("../common/tag-description");
 const tags_alphabetical_1 = require("../common/tags-alphabetical");
@@ -13,6 +14,7 @@ exports.rules = {
     spec: spec_1.Spec,
     assertions: assertions_1.Assertions,
     'info-contact': info_contact_1.InfoContact,
+    'info-license-strict': info_license_strict_1.InfoLicenseStrict,
     'operation-operationId': operation_operationId_1.OperationOperationId,
     'channels-kebab-case': channels_kebab_case_1.ChannelsKebabCase,
     'no-channel-trailing-slash': no_channel_trailing_slash_1.NoChannelTrailingSlash,

package/lib/rules/async2/no-channel-trailing-slash.d.ts

@@ -1,2 +1,2 @@
-import { Async2Rule } from '../../visitors';
+import type { Async2Rule } from '../../visitors';
 export declare const NoChannelTrailingSlash: Async2Rule;

package/lib/rules/async3/channels-kebab-case.d.ts

@@ -0,0 +1,2 @@
+import type { Async3Rule } from '../../visitors';
+export declare const ChannelsKebabCase: Async3Rule;

package/lib/rules/async3/channels-kebab-case.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsKebabCase = void 0;
+const ChannelsKebabCase = () => {
+    return {
+        Channel(channel, { report }) {
+            const segments = (channel.address || '')
+                .split(/[/.:]/) // split on / or : as likely channel namespacers
+                .filter((s) => s !== ''); // filter out empty segments
+            if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
+                report({
+                    message: `\`${channel.address}\` does not use kebab-case.`,
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+exports.ChannelsKebabCase = ChannelsKebabCase;

package/lib/rules/async3/index.d.ts

@@ -0,0 +1,3 @@
+import type { Async3RuleSet } from '../../oas-types';
+export declare const rules: Async3RuleSet<'built-in'>;
+export declare const preprocessors: {};

package/lib/rules/async3/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessors = exports.rules = void 0;
+const assertions_1 = require("../common/assertions");
+const spec_1 = require("../common/spec");
+const info_contact_1 = require("../common/info-contact");
+const info_license_strict_1 = require("../common/info-license-strict");
+const operation_operationId_1 = require("../common/operation-operationId");
+const tag_description_1 = require("../common/tag-description");
+const tags_alphabetical_1 = require("../common/tags-alphabetical");
+const channels_kebab_case_1 = require("./channels-kebab-case");
+const no_channel_trailing_slash_1 = require("./no-channel-trailing-slash");
+exports.rules = {
+    spec: spec_1.Spec,
+    assertions: assertions_1.Assertions,
+    'info-contact': info_contact_1.InfoContact,
+    'info-license-strict': info_license_strict_1.InfoLicenseStrict,
+    'operation-operationId': operation_operationId_1.OperationOperationId,
+    'channels-kebab-case': channels_kebab_case_1.ChannelsKebabCase,
+    'no-channel-trailing-slash': no_channel_trailing_slash_1.NoChannelTrailingSlash,
+    'tag-description': tag_description_1.TagDescription,
+    'tags-alphabetical': tags_alphabetical_1.TagsAlphabetical,
+};
+exports.preprocessors = {};

package/lib/rules/async3/no-channel-trailing-slash.d.ts

@@ -0,0 +1,2 @@
+import type { Async3Rule } from '../../visitors';
+export declare const NoChannelTrailingSlash: Async3Rule;

package/lib/rules/async3/no-channel-trailing-slash.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoChannelTrailingSlash = void 0;
+const NoChannelTrailingSlash = () => {
+    return {
+        Channel(channel, { report, location }) {
+            if (channel.address.endsWith('/') && channel.address !== '/') {
+                report({
+                    message: `\`${channel.address}\` should not have a trailing slash.`,
+                    location: location.key(),
+                });
+            }
+        },
+    };
+};
+exports.NoChannelTrailingSlash = NoChannelTrailingSlash;

package/lib/rules/common/assertions/asserts.d.ts

@@ -1,5 +1,5 @@
-import { AssertionContext, AssertResult, CustomFunction } from 'core/src/config/types';
-import { Location } from '../../../ref-utils';
+import type { AssertionContext, AssertResult, CustomFunction } from '../../../config/types';
+import type { Location } from '../../../ref-utils';
 export type AssertionFnContext = AssertionContext & {
     baseLocation: Location;
     rawValue?: any;