@mintlify/validation 0.1.67 → 0.1.68

package/dist/mint-config/validateVersionsInNavigation.js

@@ -1,8 +1,7 @@
 import { MintValidationResults } from './common.js';
 import { navigationSchema } from './schemas/navigation.js';
-export function flattenNavigationVersions(nav, versions) {
-    if (versions === void 0) { versions = []; }
-    nav.forEach(function (val) {
+export function flattenNavigationVersions(nav, versions = []) {
+    nav.forEach((val) => {
         if (val == null || typeof val === 'string') {
             return versions;
         }
@@ -16,24 +15,22 @@ export function flattenNavigationVersions(nav, versions) {
     });
     return versions;
 }
-export function validateVersionsInNavigation(navigation, versions) {
-    if (versions === void 0) { versions = []; }
-    var results = new MintValidationResults();
+export function validateVersionsInNavigation(navigation, versions = []) {
+    const results = new MintValidationResults();
     if (navigation == null || !navigationSchema.safeParse(navigation).success) {
         return results;
     }
-    var versionsFromNavigation = flattenNavigationVersions(navigation);
-    versionsFromNavigation.forEach(function (v) {
+    const versionsFromNavigation = flattenNavigationVersions(navigation);
+    versionsFromNavigation.forEach((v) => {
         if (versions && !versions.includes(v)) {
-            results.errors.push("Version ".concat(v, " is not included in the versions array, but is used in the navigation. Please add ").concat(v, " to the versions array."));
+            results.errors.push(`Version ${v} is not included in the versions array, but is used in the navigation. Please add ${v} to the versions array.`);
         }
     });
     if (versionsFromNavigation.length === 0 && versions.length > 0) {
         results.warnings.push('You have versions defined in the config, but no versions are used in the navigation.');
     }
-    navigation.forEach(function (nav) {
-        var _a;
-        (_a = results.warnings).push.apply(_a, warnVersionNesting(nav, null));
+    navigation.forEach((nav) => {
+        results.warnings.push(...warnVersionNesting(nav, null));
     });
     return results;
 }
@@ -41,13 +38,13 @@ function warnVersionNesting(navigation, currentVersion) {
     if (typeof navigation === 'string') {
         return [];
     }
-    var warnings = [];
+    const warnings = [];
     if (navigation.version && currentVersion != null && navigation.version !== currentVersion) {
-        warnings.push("Please do not set versions on groups nested inside a group that already has a version. The group \"".concat(navigation.group, "\" has version \"").concat(navigation.version, "\" set and it is nested in a group that has the version \"").concat(currentVersion, "\" set."));
+        warnings.push(`Please do not set versions on groups nested inside a group that already has a version. The group "${navigation.group}" has version "${navigation.version}" set and it is nested in a group that has the version "${currentVersion}" set.`);
     }
     if (navigation.pages) {
         return warnings.concat(navigation.pages
-            .map(function (entry) { return warnVersionNesting(entry, currentVersion || navigation.version); })
+            .map((entry) => warnVersionNesting(entry, currentVersion || navigation.version))
             .flat()
             .filter(Boolean));
     }

package/dist/openapi/convertOpenApi.js

@@ -1,166 +1,110 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { convertParameters } from './convertParameters.js';
 import { convertSchema } from './convertSchema.js';
 import { convertSecurity } from './convertSecurity.js';
 import { convertServers } from './convertServers.js';
-export var generateMessage = function (path, messages) {
-    if (messages === void 0) { messages = []; }
-    var pathString = path
-        .map(function (component) { return component.replace('\\', '\\\\').replace('/', '\\/'); })
+export const generateMessage = (path, messages = []) => {
+    const pathString = path
+        .map((component) => component.replace('\\', '\\\\').replace('/', '\\/'))
         .join('/');
-    return __spreadArray([pathString], messages, true).join('\n');
+    return [pathString, ...messages].join('\n');
 };
-var InvalidSchemaError = /** @class */ (function (_super) {
-    __extends(InvalidSchemaError, _super);
-    function InvalidSchemaError(path) {
-        var messages = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            messages[_i - 1] = arguments[_i];
-        }
-        var _this = _super.call(this, generateMessage(path, messages)) || this;
-        _this.name = 'InvalidSchemaError';
-        Object.setPrototypeOf(_this, InvalidSchemaError.prototype);
-        return _this;
+export class InvalidSchemaError extends Error {
+    constructor(path, ...messages) {
+        super(generateMessage(path, messages));
+        this.name = 'InvalidSchemaError';
+        Object.setPrototypeOf(this, InvalidSchemaError.prototype);
     }
-    return InvalidSchemaError;
-}(Error));
-export { InvalidSchemaError };
-var ImpossibleSchemaError = /** @class */ (function (_super) {
-    __extends(ImpossibleSchemaError, _super);
-    function ImpossibleSchemaError(path) {
-        var messages = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            messages[_i - 1] = arguments[_i];
-        }
-        var _this = _super.call(this, generateMessage(path, messages)) || this;
-        _this.name = 'ImpossibleSchemaError';
-        Object.setPrototypeOf(_this, ImpossibleSchemaError.prototype);
-        return _this;
+}
+export class ImpossibleSchemaError extends Error {
+    constructor(path, ...messages) {
+        super(generateMessage(path, messages));
+        this.name = 'ImpossibleSchemaError';
+        Object.setPrototypeOf(this, ImpossibleSchemaError.prototype);
     }
-    return ImpossibleSchemaError;
-}(Error));
-export { ImpossibleSchemaError };
-var ConversionError = /** @class */ (function (_super) {
-    __extends(ConversionError, _super);
-    function ConversionError(path) {
-        var messages = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            messages[_i - 1] = arguments[_i];
-        }
-        var _this = _super.call(this, generateMessage(path, messages)) || this;
-        _this.name = 'ConversionError';
-        Object.setPrototypeOf(_this, ConversionError.prototype);
-        return _this;
+}
+export class ConversionError extends Error {
+    constructor(path, ...messages) {
+        super(generateMessage(path, messages));
+        this.name = 'ConversionError';
+        Object.setPrototypeOf(this, ConversionError.prototype);
     }
-    return ConversionError;
-}(Error));
-export { ConversionError };
-export var convertBody = function (path, body) {
+}
+export const convertBody = (path, body) => {
     if (body === undefined) {
         return {};
     }
-    var newEntries = Object.entries(body.content).map(function (_a) {
-        var contentType = _a[0], mediaObject = _a[1];
+    const newEntries = Object.entries(body.content).map(([contentType, mediaObject]) => {
         return [
             contentType,
-            convertSchema(__spreadArray(__spreadArray([], path, true), [contentType, 'schema'], false), mediaObject.schema, body.required),
+            convertSchema([...path, contentType, 'schema'], mediaObject.schema, body.required),
         ];
     });
     return Object.fromEntries(newEntries);
 };
-export var convertResponses = function (path, responses) {
-    var newEntries = Object.entries(responses).map(function (_a) {
-        var statusCode = _a[0], response = _a[1];
-        return [
-            statusCode,
-            convertResponse(__spreadArray(__spreadArray([], path, true), [statusCode], false), response),
-        ];
-    });
+export const convertResponses = (path, responses) => {
+    const newEntries = Object.entries(responses).map(([statusCode, response]) => [
+        statusCode,
+        convertResponse([...path, statusCode], response),
+    ]);
     return Object.fromEntries(newEntries);
 };
-export var convertResponse = function (path, response) {
+export const convertResponse = (path, response) => {
     if (response.content === undefined) {
         return {};
     }
-    var newEntries = Object.entries(response.content).map(function (_a) {
-        var contentType = _a[0], mediaType = _a[1];
-        return [
-            contentType,
-            convertSchema(__spreadArray(__spreadArray([], path, true), ['content', contentType, 'schema'], false), mediaType.schema),
-        ];
-    });
+    const newEntries = Object.entries(response.content).map(([contentType, mediaType]) => [
+        contentType,
+        convertSchema([...path, 'content', contentType, 'schema'], mediaType.schema),
+    ]);
     return Object.fromEntries(newEntries);
 };
-export var convertOpenAPIV3_1ToEndpoint = function (spec, path, method) {
+export const convertOpenAPIV3_1ToEndpoint = (spec, path, method) => {
     var _a, _b, _c, _d, _e;
-    var paths = spec.paths;
+    const paths = spec.paths;
     if (paths === undefined) {
         throw new InvalidSchemaError(['#'], 'paths not defined');
     }
-    var pathObject = paths[path];
+    const pathObject = paths[path];
     if (pathObject === undefined) {
-        throw new InvalidSchemaError(['#', 'paths'], "path not defined: ".concat(path));
+        throw new InvalidSchemaError(['#', 'paths'], `path not defined: ${path}`);
     }
-    var operationObject = pathObject[method];
+    const operationObject = pathObject[method];
     if (operationObject === undefined) {
-        throw new InvalidSchemaError(['#', 'paths', path], "operation does not exist: ".concat(method));
+        throw new InvalidSchemaError(['#', 'paths', path], `operation does not exist: ${method}`);
     }
-    var securityRequirements = (_a = operationObject.security) !== null && _a !== void 0 ? _a : spec.security;
-    var securitySchemes = (_b = spec.components) === null || _b === void 0 ? void 0 : _b.securitySchemes;
-    var security = convertSecurity({
-        securityRequirements: securityRequirements,
-        securitySchemes: securitySchemes,
+    const securityRequirements = (_a = operationObject.security) !== null && _a !== void 0 ? _a : spec.security;
+    const securitySchemes = (_b = spec.components) === null || _b === void 0 ? void 0 : _b.securitySchemes;
+    const security = convertSecurity({
+        securityRequirements,
+        securitySchemes,
     });
-    var pathParameters = pathObject.parameters;
-    var operationParameters = operationObject.parameters;
-    var parameters = convertParameters({
+    const pathParameters = pathObject.parameters;
+    const operationParameters = operationObject.parameters;
+    const parameters = convertParameters({
         path: ['#', 'paths', path],
-        method: method,
+        method,
         pathParameters: pathParameters,
         operationParameters: operationParameters,
     });
-    var servers = convertServers({
+    const servers = convertServers({
         servers: (_d = (_c = operationObject.servers) !== null && _c !== void 0 ? _c : pathObject.servers) !== null && _d !== void 0 ? _d : spec.servers,
     });
-    var description = (_e = operationObject.description) !== null && _e !== void 0 ? _e : pathObject === null || pathObject === void 0 ? void 0 : pathObject.description;
-    var requestBody = operationObject.requestBody;
-    var body = convertBody(['#', 'paths', path, method, 'requestBody'], requestBody);
-    var deprecated = !!operationObject.deprecated;
-    var response = convertResponses(['#', 'paths', path, method, 'responses'], operationObject.responses);
+    const description = (_e = operationObject.description) !== null && _e !== void 0 ? _e : pathObject === null || pathObject === void 0 ? void 0 : pathObject.description;
+    const requestBody = operationObject.requestBody;
+    const body = convertBody(['#', 'paths', path, method, 'requestBody'], requestBody);
+    const deprecated = !!operationObject.deprecated;
+    const response = convertResponses(['#', 'paths', path, method, 'responses'], operationObject.responses);
     return {
-        description: description,
-        path: path,
-        method: method,
-        servers: servers,
+        description,
+        path,
+        method,
+        servers,
         request: {
-            security: security,
-            parameters: parameters,
-            body: body,
+            security,
+            parameters,
+            body,
         },
-        response: response,
-        deprecated: deprecated,
+        response,
+        deprecated,
     };
 };

package/dist/openapi/convertParameters.js

@@ -1,56 +1,45 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { InvalidSchemaError } from './convertOpenApi.js';
 import { convertSchema, copyKeyIfDefined } from './convertSchema.js';
-export var convertParameters = function (_a) {
-    var path = _a.path, method = _a.method, pathParameters = _a.pathParameters, operationParameters = _a.operationParameters;
-    var parameterSections = {
+export const convertParameters = ({ path, method, pathParameters, operationParameters, }) => {
+    const parameterSections = {
         path: {},
         query: {},
         header: {},
         cookie: {},
     };
-    pathParameters === null || pathParameters === void 0 ? void 0 : pathParameters.forEach(function (parameterObject, i) {
+    pathParameters === null || pathParameters === void 0 ? void 0 : pathParameters.forEach((parameterObject, i) => {
         addParameter({
-            path: __spreadArray(__spreadArray([], path, true), ['parameters', i.toString()], false),
+            path: [...path, 'parameters', i.toString()],
             parameter: parameterObject,
-            parameterSections: parameterSections,
+            parameterSections,
         });
     });
-    operationParameters === null || operationParameters === void 0 ? void 0 : operationParameters.forEach(function (parameterObject, i) {
+    operationParameters === null || operationParameters === void 0 ? void 0 : operationParameters.forEach((parameterObject, i) => {
         addParameter({
-            path: __spreadArray(__spreadArray([], path, true), [method, 'parameters', i.toString()], false),
+            path: [...path, method, 'parameters', i.toString()],
             parameter: parameterObject,
-            parameterSections: parameterSections,
+            parameterSections,
         });
     });
     return parameterSections;
 };
-var addParameter = function (_a) {
-    var path = _a.path, parameter = _a.parameter, parameterSections = _a.parameterSections;
+const addParameter = ({ path, parameter, parameterSections }) => {
     if (!['path', 'header', 'query', 'cookie'].includes(parameter.in)) {
-        throw new InvalidSchemaError(path, "invalid parameter location: '".concat(parameter.in, "'"));
+        throw new InvalidSchemaError(path, `invalid parameter location: '${parameter.in}'`);
     }
-    var location = parameter.in;
+    const location = parameter.in;
     if (location === 'path') {
-        var newParameter = {
+        const newParameter = {
             required: true,
-            schema: convertSchema(__spreadArray(__spreadArray([], path, true), ['schema'], false), parameter.schema, true),
+            schema: convertSchema([...path, 'schema'], parameter.schema, true),
         };
         copyKeyIfDefined('description', parameter, newParameter);
         copyKeyIfDefined('deprecated', parameter, newParameter);
         parameterSections.path[parameter.name] = newParameter;
     }
     else {
-        var newParameter = {
-            schema: convertSchema(__spreadArray(__spreadArray([], path, true), ['schema'], false), parameter.schema, true),
+        const newParameter = {
+            schema: convertSchema([...path, 'schema'], parameter.schema, true),
         };
         copyKeyIfDefined('description', parameter, newParameter);
         copyKeyIfDefined('deprecated', parameter, newParameter);