@kubb/agent 4.33.1 → 4.33.3

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/identity.js

@@ -0,0 +1,4 @@
+export function identity(value) {
+    return value;
+}
+//# sourceMappingURL=identity.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-custom-rule-id.js

@@ -0,0 +1,4 @@
+export function isCustomRuleId(id) {
+    return id.includes('/');
+}
+//# sourceMappingURL=is-custom-rule-id.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-defined.js

@@ -0,0 +1,4 @@
+export function isDefined(x) {
+    return x !== undefined;
+}
+//# sourceMappingURL=is-defined.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-empty-array.js

@@ -0,0 +1,4 @@
+export function isEmptyArray(value) {
+    return Array.isArray(value) && value.length === 0;
+}
+//# sourceMappingURL=is-empty-array.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-empty-object.js

@@ -0,0 +1,5 @@
+import { isPlainObject } from './is-plain-object.js';
+export function isEmptyObject(value) {
+    return isPlainObject(value) && Object.keys(value).length === 0;
+}
+//# sourceMappingURL=is-empty-object.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-not-empty-array.js

@@ -0,0 +1,4 @@
+export function isNotEmptyArray(args) {
+    return Array.isArray(args) && !!args.length;
+}
+//# sourceMappingURL=is-not-empty-array.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-not-empty-object.js

@@ -0,0 +1,6 @@
+import { isEmptyObject } from './is-empty-object.js';
+import { isPlainObject } from './is-plain-object.js';
+export function isNotEmptyObject(obj) {
+    return isPlainObject(obj) && !isEmptyObject(obj);
+}
+//# sourceMappingURL=is-not-empty-object.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-not-string.js

@@ -0,0 +1,5 @@
+import { isString } from './is-string.js';
+export function isNotString(value) {
+    return !isString(value);
+}
+//# sourceMappingURL=is-not-string.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-ordered.js

@@ -0,0 +1,27 @@
+export function isOrdered(value, options) {
+    const direction = options.direction || options;
+    const property = options.property;
+    for (let i = 1; i < value.length; i++) {
+        let currValue = value[i];
+        let prevVal = value[i - 1];
+        if (property) {
+            const currPropValue = value[i][property];
+            const prevPropValue = value[i - 1][property];
+            if (!currPropValue || !prevPropValue) {
+                return false; // property doesn't exist, so collection is not ordered
+            }
+            currValue = currPropValue;
+            prevVal = prevPropValue;
+        }
+        if (typeof currValue === 'string' && typeof prevVal === 'string') {
+            currValue = currValue.toLowerCase();
+            prevVal = prevVal.toLowerCase();
+        }
+        const result = direction === 'asc' ? currValue >= prevVal : currValue <= prevVal;
+        if (!result) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=is-ordered.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-path-parameter.js

@@ -0,0 +1,4 @@
+export function isPathParameter(pathSegment) {
+    return pathSegment.startsWith('{') && pathSegment.endsWith('}');
+}
+//# sourceMappingURL=is-path-parameter.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-plain-object.js

@@ -0,0 +1,4 @@
+export function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+//# sourceMappingURL=is-plain-object.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-string.js

@@ -0,0 +1,4 @@
+export function isString(value) {
+    return typeof value === 'string';
+}
+//# sourceMappingURL=is-string.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/is-truthy.js

@@ -0,0 +1,4 @@
+export function isTruthy(value) {
+    return !!value;
+}
+//# sourceMappingURL=is-truthy.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/keys-of.js

@@ -0,0 +1,6 @@
+export function keysOf(obj) {
+    if (!obj)
+        return [];
+    return Object.keys(obj);
+}
+//# sourceMappingURL=keys-of.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/make-ref-id.js

@@ -0,0 +1,4 @@
+export function makeRefId(absoluteRef, pointer) {
+    return absoluteRef + '::' + pointer;
+}
+//# sourceMappingURL=make-ref-id.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/next-tick.js

@@ -0,0 +1,6 @@
+export function nextTick() {
+    return new Promise((resolve) => {
+        setTimeout(resolve);
+    });
+}
+//# sourceMappingURL=next-tick.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/oas-has-component.js

@@ -0,0 +1,4 @@
+export function hasComponent(components, key) {
+    return key in components;
+}
+//# sourceMappingURL=oas-has-component.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/omit.js

@@ -0,0 +1,8 @@
+export function omit(obj, keys) {
+    const result = { ...obj };
+    keys.forEach((key) => {
+        delete result[key];
+    });
+    return result;
+}
+//# sourceMappingURL=omit.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/pause.js

@@ -0,0 +1,4 @@
+export async function pause(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=pause.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/pluralize.js

@@ -0,0 +1,8 @@
+import pluralizeOne from 'pluralize';
+export function pluralize(sentence, count, inclusive) {
+    return sentence
+        .split(' ')
+        .map((word) => pluralizeOne(word, count, inclusive))
+        .join(' ');
+}
+//# sourceMappingURL=pluralize.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/read-file-from-url.js

@@ -0,0 +1,26 @@
+import picomatch from 'picomatch';
+import { env } from '../env.js';
+export async function readFileFromUrl(url, config) {
+    const headers = {};
+    for (const header of config.headers) {
+        if (match(url, header.matches)) {
+            headers[header.name] =
+                header.envVariable !== undefined ? env[header.envVariable] || '' : header.value;
+        }
+    }
+    const req = await (config.customFetch || fetch)(url, {
+        headers: headers,
+    });
+    if (!req.ok) {
+        throw new Error(`Failed to load ${url}: ${req.status} ${req.statusText}`);
+    }
+    return { body: await req.text(), mimeType: req.headers.get('content-type') };
+}
+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 picomatch.isMatch(url, pattern);
+}
+//# sourceMappingURL=read-file-from-url.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/regex-from-string.js

@@ -0,0 +1,5 @@
+export function regexFromString(input) {
+    const matches = input.match(/^\/(.*)\/(.*)|(.*)/);
+    return matches && new RegExp(matches[1] || matches[3], matches[2]);
+}
+//# sourceMappingURL=regex-from-string.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/scorecards.js

@@ -0,0 +1,99 @@
+import * as redoclyConfig from '@redocly/config';
+import { dequal } from './dequal.js';
+import { isPlainObject } from './is-plain-object.js';
+function transformEntityTypeName(subjectType, entityType) {
+    const capitalizedEntityType = entityType
+        .split('-')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+    const specificType = capitalizedEntityType + subjectType;
+    if (Object.values(redoclyConfig.ENTITY_NODE_TYPE_NAMES).includes(specificType)) {
+        return specificType;
+    }
+    return subjectType;
+}
+export function transformScorecardRulesToAssertions(entityType, rules) {
+    const assertionConfig = {};
+    for (const [ruleKey, ruleValue] of Object.entries(rules)) {
+        if (isAssertionRule(ruleKey, ruleValue)) {
+            if (ruleValue.severity === 'off') {
+                continue;
+            }
+            assertionConfig[ruleKey] = {
+                ...buildAssertionWithNormalizedTypes(entityType, ruleKey, ruleValue),
+            };
+        }
+        else {
+            assertionConfig[ruleKey] = ruleValue;
+        }
+    }
+    return assertionConfig;
+}
+export function categorizeAssertions(assertionConfig) {
+    const entityRules = {};
+    const apiRules = {};
+    for (const [ruleKey, ruleValue] of Object.entries(assertionConfig)) {
+        if (isAssertionRule(ruleKey, ruleValue)) {
+            const assertion = ruleValue;
+            if (isEntityAssertion(assertion)) {
+                entityRules[ruleKey] = assertion;
+            }
+            else {
+                apiRules[ruleKey] = assertion;
+            }
+        }
+        else {
+            apiRules[ruleKey] = ruleValue;
+        }
+    }
+    return { entityRules, apiRules };
+}
+export function findDataSchemaInDocument(schemaKey, schemaJson, document) {
+    if (!isPlainObject(document.parsed) || !isPlainObject(document.parsed.components)) {
+        return null;
+    }
+    const components = document.parsed.components;
+    const schemas = 'schemas' in components ? components.schemas : undefined;
+    if (!schemas || !(schemaKey in schemas)) {
+        return null;
+    }
+    const foundSchema = schemas[schemaKey];
+    try {
+        const expectedSchema = JSON.parse(schemaJson);
+        if (dequal(foundSchema, expectedSchema)) {
+            return foundSchema;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function isAssertionRule(ruleKey, ruleValue) {
+    return ruleKey.startsWith('rule/') && isPlainObject(ruleValue);
+}
+function isEntityAssertion(assertion) {
+    return Object.values(redoclyConfig.ENTITY_NODE_TYPE_NAMES).some((entityTypeName) => assertion.subject.type === entityTypeName);
+}
+function buildAssertionWithNormalizedTypes(entityType, ruleKey, rawAssertion) {
+    const transformedSubjectType = transformEntityTypeName(rawAssertion.subject.type, entityType);
+    const transformedWhere = rawAssertion.where?.map((whereClause) => ({
+        ...whereClause,
+        subject: {
+            ...whereClause.subject,
+            type: transformEntityTypeName(whereClause.subject.type, entityType),
+        },
+    }));
+    return {
+        assertionId: ruleKey,
+        subject: {
+            ...rawAssertion.subject,
+            type: transformedSubjectType,
+        },
+        assertions: rawAssertion.assertions,
+        ...(transformedWhere && { where: transformedWhere }),
+        ...(rawAssertion.message && { message: rawAssertion.message }),
+        ...(rawAssertion.severity && { severity: rawAssertion.severity }),
+    };
+}
+//# sourceMappingURL=scorecards.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/slash.js

@@ -0,0 +1,11 @@
+/**
+ * Convert Windows backslash paths to slash paths: foo\\bar ➔ foo/bar
+ */
+export function slash(path) {
+    const isExtendedLengthPath = /^\\\\\?\\/.test(path);
+    if (isExtendedLengthPath) {
+        return path;
+    }
+    return path.replace(/\\/g, '/');
+}
+//# sourceMappingURL=slash.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/split-camel-case-into-words.js

@@ -0,0 +1,13 @@
+import { isTruthy } from './is-truthy.js';
+export function splitCamelCaseIntoWords(str) {
+    const camel = str
+        .split(/(?:[-._])|([A-Z][a-z]+)/)
+        .filter(isTruthy)
+        .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]);
+}
+//# sourceMappingURL=split-camel-case-into-words.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/stack.js

@@ -0,0 +1,7 @@
+export function pushStack(head, value) {
+    return { prev: head, value };
+}
+export function popStack(head) {
+    return head?.prev ?? null;
+}
+//# sourceMappingURL=stack.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/validate-mime-type.js

@@ -0,0 +1,31 @@
+export 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(),
+            });
+        }
+    }
+}
+export 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(),
+            });
+        }
+    }
+}
+//# sourceMappingURL=validate-mime-type.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/utils/yaml-fs-helper.js

@@ -0,0 +1,23 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { parseYaml } from '../js-yaml/index.js';
+import { isAbsoluteUrl } from '../ref-utils.js';
+export { parseYaml, stringifyYaml } from '../js-yaml/index.js';
+export async function loadYaml(filename) {
+    const contents = await fs.promises.readFile(filename, 'utf-8');
+    return parseYaml(contents);
+}
+export function yamlAndJsonSyncReader(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return parseYaml(content);
+}
+export function resolveRelativePath(filePath, base) {
+    if (isAbsoluteUrl(filePath) || base === undefined) {
+        return filePath;
+    }
+    return path.resolve(path.dirname(base), filePath);
+}
+export function readFileAsStringSync(filePath) {
+    return fs.readFileSync(filePath, 'utf-8');
+}
+//# sourceMappingURL=yaml-fs-helper.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/visitors.js

@@ -0,0 +1,177 @@
+import { SpecExtension } from './types/index.js';
+import { isPlainObject } from './utils/is-plain-object.js';
+const legacyTypesMap = {
+    Root: 'DefinitionRoot',
+    ServerVariablesMap: 'ServerVariableMap',
+    Paths: ['PathMap', 'PathsMap'],
+    CallbacksMap: 'CallbackMap',
+    MediaTypesMap: 'MediaTypeMap',
+    ExamplesMap: 'ExampleMap',
+    EncodingMap: 'EncodingsMap',
+    HeadersMap: 'HeaderMap',
+    LinksMap: 'LinkMap',
+    OAuth2Flows: 'SecuritySchemeFlows',
+    Responses: 'ResponsesMap',
+};
+export 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, message, visitor } of visitorsConfig) {
+        normalizeVisitorLevel({ ruleId, severity, message }, 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 (const type of Object.values(from.properties)) {
+            if (type === to) {
+                addWeakFromStack(ruleConf, stack);
+                continue;
+            }
+            if (isPlainObject(type) && type.name !== undefined) {
+                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 && typeof from.items !== 'function') {
+            if (from.items === to) {
+                addWeakFromStack(ruleConf, stack);
+            }
+            else if (from.items.name !== undefined) {
+                possibleChildren.add(from.items);
+            }
+        }
+        if (from.extensionsPrefix) {
+            possibleChildren.add(SpecExtension);
+        }
+        for (const 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({
+                    ...ruleConf,
+                    visit: () => undefined,
+                    depth: 0,
+                    context: {
+                        isSkippedLevel: true,
+                        seen: new Set(),
+                        parent: parentContext,
+                    },
+                });
+            }
+        }
+    }
+    function findLegacyVisitorNode(visitor, typeName) {
+        if (Array.isArray(typeName)) {
+            const name = typeName.find((name) => visitor[name]) || undefined;
+            return name && visitor[name];
+        }
+        return visitor[typeName];
+    }
+    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] ||
+                findLegacyVisitorNode(visitor, legacyTypesMap[typeName]));
+            const normalizedTypeVisitor = normalizedVisitors[typeName];
+            if (!typeVisitor)
+                continue;
+            let visitorEnter;
+            let visitorLeave;
+            let visitorSkip;
+            const isObjectVisitor = isPlainObject(typeVisitor);
+            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 standardKeysCount = (visitorEnter ? 1 : 0) + (visitorLeave ? 1 : 0) + (visitorSkip ? 1 : 0);
+            const hasNestedVisitors = isObjectVisitor && Object.keys(typeVisitor).length > standardKeysCount;
+            const context = {
+                activatedOn: null,
+                type: types[typeName],
+                parent: parentContext,
+                isSkippedLevel: false,
+            };
+            if (hasNestedVisitors) {
+                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({
+                    ...ruleConf,
+                    visit: visitorEnter || (() => undefined),
+                    skip: visitorSkip,
+                    depth,
+                    context,
+                });
+            }
+            if (visitorLeave) {
+                if (typeof visitorLeave !== 'function') {
+                    throw new Error('DEV: should be function');
+                }
+                normalizedTypeVisitor.leave.push({
+                    ...ruleConf,
+                    visit: visitorLeave,
+                    depth,
+                    context,
+                });
+            }
+        }
+    }
+}
+//# sourceMappingURL=visitors.js.map