@kubb/agent 5.0.0-alpha.36 → 5.0.0-alpha.38

package/.output/server/node_modules/@redocly/config/lib/scorecards-config-schema.js

@@ -1,242 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scorecardsConfigSchema = exports.scorecardSchema = void 0;
-const common_1 = require("./common");
-const comparisonOperatorSchema = {
-    type: 'string',
-    enum: [
-        'eq',
-        'in',
-        'gt',
-        'gte',
-        'lt',
-        'lte',
-        'contains',
-        'startsWith',
-        'endsWith',
-        'exists',
-        'isEmpty',
-        'between',
-        'matches',
-        'some',
-        'every',
-        'none',
-    ],
-};
-const logicalOperatorSchema = {
-    type: 'string',
-    enum: ['and', 'or'],
-};
-// Base condition schema with field, operator, value, modifier, and match properties
-const conditionSchema = {
-    type: 'object',
-    properties: {
-        field: { type: 'string' },
-        operator: comparisonOperatorSchema,
-        value: {
-            oneOf: [{ type: 'boolean' }, { type: 'string' }, { type: 'number' }],
-        },
-        modifier: { type: 'string', enum: ['not'] },
-        match: {
-            type: 'array',
-            items: {
-                type: 'object',
-                properties: {
-                    field: { type: 'string' },
-                    operator: comparisonOperatorSchema,
-                    value: {
-                        oneOf: [{ type: 'boolean' }, { type: 'string' }, { type: 'number' }],
-                    },
-                    modifier: { type: 'string', enum: ['not'] },
-                },
-            },
-        },
-    },
-};
-// Schema for a logical operator with conditions (used for nesting)
-const logicalOperatorConditionSchema = {
-    type: 'object',
-    properties: {
-        operator: logicalOperatorSchema,
-        conditions: {
-            type: 'array',
-            items: conditionSchema, // At the deepest level, only simple conditions
-        },
-    },
-    required: ['operator', 'conditions'],
-    additionalProperties: false,
-};
-// Conditions schema allowing nested conditions with up to 2 levels of recursion
-const conditionsSchema = {
-    type: 'array',
-    items: {
-        oneOf: [
-            conditionSchema,
-            {
-                type: 'object',
-                properties: {
-                    operator: logicalOperatorSchema,
-                    conditions: {
-                        type: 'array',
-                        items: {
-                            oneOf: [conditionSchema, logicalOperatorConditionSchema],
-                        },
-                    },
-                },
-                required: ['operator', 'conditions'],
-                additionalProperties: false,
-            },
-        ],
-    },
-};
-const entityRuleAssertionSchema = {
-    type: 'object',
-    properties: {
-        defined: { type: 'boolean' },
-        nonEmpty: { type: 'boolean' },
-        eq: {},
-        gt: { type: 'number' },
-        gte: { type: 'number' },
-        lt: { type: 'number' },
-        lte: { type: 'number' },
-        const: {},
-    },
-    additionalProperties: false,
-};
-const entityRuleWhereSchema = {
-    type: 'array',
-    items: {
-        type: 'object',
-        properties: {
-            subject: {
-                type: 'object',
-                properties: {
-                    type: {
-                        type: 'string',
-                        enum: ['Entity', 'EntityMetadata', 'EntityRelations', 'EntityRelation'],
-                    },
-                    property: { type: 'string' },
-                },
-                required: ['type', 'property'],
-                additionalProperties: false,
-            },
-            assertions: entityRuleAssertionSchema,
-        },
-        required: ['subject', 'assertions'],
-        additionalProperties: false,
-    },
-};
-const entityRuleSchema = {
-    type: 'object',
-    properties: {
-        title: { type: 'string' },
-        subject: {
-            type: 'object',
-            properties: {
-                type: {
-                    type: 'string',
-                    enum: ['Entity', 'EntityMetadata', 'EntityRelations', 'EntityRelation'],
-                },
-                property: { type: 'string' },
-            },
-            required: ['type', 'property'],
-            additionalProperties: false,
-        },
-        severity: {
-            type: 'string',
-            enum: ['error', 'warn', 'off'],
-        },
-        message: { type: 'string' },
-        assertions: entityRuleAssertionSchema,
-        where: entityRuleWhereSchema,
-        weight: { type: 'number', default: 1 },
-    },
-    required: ['subject', 'assertions'],
-    additionalProperties: false,
-};
-// Supports both OpenAPI/AsyncAPI rules (backward compatibility) and entity rules
-const levelRulesSchema = {
-    type: 'object',
-    additionalProperties: {
-        oneOf: [
-            { type: 'string' },
-            {
-                type: 'object',
-                properties: {
-                    severity: {
-                        type: 'string',
-                        enum: ['error', 'warn', 'off'],
-                    },
-                    weight: { type: 'number', default: 1 },
-                },
-                additionalProperties: true,
-            },
-            entityRuleSchema,
-        ],
-    },
-};
-const levelSchema = {
-    type: 'object',
-    properties: {
-        name: { type: 'string' },
-        extends: common_1.configGovernanceSchema.extends,
-        rules: levelRulesSchema,
-    },
-    required: ['name'],
-    additionalProperties: false,
-};
-const triggerEventSchema = {
-    type: 'object',
-    properties: {
-        event: {
-            type: 'string',
-            enum: ['runtime', 'manual'],
-        },
-    },
-    required: ['event'],
-    additionalProperties: false,
-};
-const triggerSchema = {
-    oneOf: [
-        triggerEventSchema,
-        {
-            type: 'array',
-            items: triggerEventSchema,
-        },
-    ],
-};
-exports.scorecardSchema = {
-    type: 'object',
-    properties: {
-        name: { type: 'string' },
-        key: { type: 'string' },
-        description: { type: 'string' },
-        entities: {
-            oneOf: [
-                conditionsSchema,
-                {
-                    type: 'object',
-                    properties: {
-                        operator: logicalOperatorSchema,
-                        conditions: conditionsSchema,
-                    },
-                    required: ['operator', 'conditions'],
-                    additionalProperties: false,
-                },
-            ],
-        },
-        levels: {
-            type: 'array',
-            items: levelSchema,
-            minItems: 1,
-        },
-        trigger: triggerSchema,
-    },
-    required: ['name', 'key', 'entities', 'levels'],
-    additionalProperties: false,
-};
-exports.scorecardsConfigSchema = {
-    type: 'array',
-    items: exports.scorecardSchema,
-};
-//# sourceMappingURL=scorecards-config-schema.js.map

package/.output/server/node_modules/@redocly/config/lib/types/api-functions-types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=api-functions-types.js.map

package/.output/server/node_modules/@redocly/config/lib/types/catalog-entity-types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=catalog-entity-types.js.map

package/.output/server/node_modules/@redocly/config/lib/types/code-walkthrough-types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=code-walkthrough-types.js.map

package/.output/server/node_modules/@redocly/config/lib/types/config-types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=config-types.js.map

package/.output/server/node_modules/@redocly/config/lib/types/index.js

@@ -1,21 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./api-functions-types"), exports);
-__exportStar(require("./config-types"), exports);
-__exportStar(require("./portal-shared-types"), exports);
-__exportStar(require("./catalog-entity-types"), exports);
-//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redocly/config/lib/types/portal-shared-types.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./code-walkthrough-types"), exports);
-//# sourceMappingURL=portal-shared-types.js.map

package/.output/server/node_modules/@redocly/config/package.json

@@ -1,28 +0,0 @@
-{
-  "name": "@redocly/config",
-  "version": "0.48.0",
-  "license": "MIT",
-  "main": "./lib/index.js",
-  "module": "./lib-esm/index.js",
-  "types": "./lib/index.d.ts",
-  "devDependencies": {
-    "@markdoc/markdoc": "0.5.2",
-    "@redocly/openapi-core": "2.25.2",
-    "@types/node": "22.18.13",
-    "@types/react": "^19.2.7",
-    "@vitest/coverage-v8": "4.0.10",
-    "react-router-dom": "^6.30.3",
-    "rimraf": "5.0.7",
-    "typescript": "5.9.3",
-    "vitest": "4.0.10"
-  },
-  "dependencies": {
-    "json-schema-to-ts": "2.7.2"
-  },
-  "scripts": {
-    "clean": "rimraf lib",
-    "compile": "tsc -p tsconfig.build.json && tsc -p tsconfig.lib-esm.json",
-    "build": "pnpm run clean && pnpm run compile",
-    "test": "vitest run src"
-  }
-}

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

@@ -1,100 +0,0 @@
-import { makeBundleVisitor } from '../bundle/bundle-visitor.js';
-import { initRules } from '../config/rules.js';
-import { RemoveUnusedComponents as RemoveUnusedComponentsOas2 } from '../decorators/oas2/remove-unused-components.js';
-import { RemoveUnusedComponents as RemoveUnusedComponentsOas3 } from '../decorators/oas3/remove-unused-components.js';
-import { detectSpec, getMajorSpecVersion } from '../detect-spec.js';
-import { resolveDocument } from '../resolve.js';
-import { normalizeTypes } from '../types/index.js';
-import { normalizeVisitors } from '../visitors.js';
-import { walkDocument } from '../walk.js';
-export async function bundleDocument(opts) {
-    const { document, config, types, externalRefResolver, dereference = false, removeUnusedComponents = false, keepUrlRefs = false, componentRenamingConflicts, } = opts;
-    const specVersion = detectSpec(document.parsed);
-    const specMajorVersion = getMajorSpecVersion(specVersion);
-    const rules = config.getRulesForSpecVersion(specMajorVersion);
-    const normalizedTypes = normalizeTypes(config.extendTypes(types, specVersion), config);
-    const preprocessors = initRules(rules, config, 'preprocessors', specVersion);
-    const decorators = initRules(rules, config, 'decorators', specVersion);
-    const ctx = {
-        problems: [],
-        specVersion,
-        config,
-        refTypes: new Map(),
-        visitorsData: {},
-    };
-    let resolvedRefMap = await resolveDocument({
-        rootDocument: document,
-        rootType: normalizedTypes.Root,
-        externalRefResolver,
-    });
-    if (preprocessors.length > 0) {
-        // Make additional pass to resolve refs defined in preprocessors.
-        walkDocument({
-            document,
-            rootType: normalizedTypes.Root,
-            normalizedVisitors: normalizeVisitors(preprocessors, normalizedTypes),
-            resolvedRefMap,
-            ctx,
-        });
-        resolvedRefMap = await resolveDocument({
-            rootDocument: document,
-            rootType: normalizedTypes.Root,
-            externalRefResolver,
-        });
-    }
-    const bundleVisitor = normalizeVisitors([
-        {
-            severity: 'error',
-            ruleId: 'bundler',
-            visitor: makeBundleVisitor({
-                version: specMajorVersion,
-                dereference,
-                rootDocument: document,
-                resolvedRefMap,
-                keepUrlRefs,
-                componentRenamingConflicts,
-            }),
-        },
-        ...decorators.filter((decorator) => decorator.ruleId !== 'remove-unused-components'),
-    ], normalizedTypes);
-    walkDocument({
-        document,
-        rootType: normalizedTypes.Root,
-        normalizedVisitors: bundleVisitor,
-        resolvedRefMap,
-        ctx,
-    });
-    if (removeUnusedComponents ||
-        config.getDecoratorSettings('remove-unused-components', specVersion).severity !== 'off') {
-        const postBundleRefMap = await resolveDocument({
-            rootDocument: document,
-            rootType: normalizedTypes.Root,
-            externalRefResolver,
-        });
-        const postBundleVisitors = normalizeVisitors([
-            {
-                severity: 'error',
-                ruleId: 'remove-unused-components',
-                visitor: specMajorVersion === 'oas2'
-                    ? RemoveUnusedComponentsOas2({})
-                    : RemoveUnusedComponentsOas3({}),
-            },
-        ], normalizedTypes);
-        walkDocument({
-            document,
-            rootType: normalizedTypes.Root,
-            normalizedVisitors: postBundleVisitors,
-            resolvedRefMap: postBundleRefMap,
-            ctx,
-        });
-    }
-    return {
-        bundle: document,
-        problems: ctx.problems.map((problem) => config.addProblemToIgnore(problem)),
-        fileDependencies: externalRefResolver.getFiles(),
-        rootType: normalizedTypes.Root,
-        refTypes: ctx.refTypes,
-        visitorsData: ctx.visitorsData,
-    };
-}
-//# sourceMappingURL=bundle-document.js.map

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

@@ -1,260 +0,0 @@
-import { isAbsoluteUrl, replaceRef, isExternalValue, isRef, pointerBaseName, refBaseName, isMappingRef, } from '../ref-utils.js';
-import { reportUnresolvedRef } from '../rules/common/no-unresolved-refs.js';
-import { dequal } from '../utils/dequal.js';
-import { makeRefId } from '../utils/make-ref-id.js';
-export function mapTypeToComponent(typeName, version) {
-    switch (version) {
-        case 'oas3':
-            switch (typeName) {
-                case 'Schema':
-                    return 'schemas';
-                case 'Parameter':
-                    return 'parameters';
-                case 'Response':
-                    return 'responses';
-                case 'Example':
-                    return 'examples';
-                case 'RequestBody':
-                    return 'requestBodies';
-                case 'Header':
-                    return 'headers';
-                case 'SecuritySchema':
-                    return 'securitySchemes';
-                case 'Link':
-                    return 'links';
-                case 'Callback':
-                    return 'callbacks';
-                case 'MediaTypesMap':
-                    return 'mediaTypes';
-                default:
-                    return null;
-            }
-        case 'oas2':
-            switch (typeName) {
-                case 'Schema':
-                    return 'definitions';
-                case 'Parameter':
-                    return 'parameters';
-                case 'Response':
-                    return 'responses';
-                default:
-                    return null;
-            }
-        case 'async2':
-            switch (typeName) {
-                case 'Schema':
-                    return 'schemas';
-                case 'Parameter':
-                    return 'parameters';
-                default:
-                    return null;
-            }
-        case 'async3':
-            switch (typeName) {
-                case 'Schema':
-                    return 'schemas';
-                case 'Parameter':
-                    return 'parameters';
-                default:
-                    return null;
-            }
-        case 'arazzo1':
-            switch (typeName) {
-                case 'Root.workflows_items.parameters_items':
-                case 'Root.workflows_items.steps_items.parameters_items':
-                    return 'parameters';
-                default:
-                    return null;
-            }
-        case 'overlay1':
-            switch (typeName) {
-                default:
-                    return null;
-            }
-        case 'openrpc1':
-            switch (typeName) {
-                case 'ContentDescriptor':
-                    return 'contentDescriptors';
-                case 'Schema':
-                    return 'schemas';
-                case 'Example':
-                    return 'examples';
-                case 'Link':
-                    return 'links';
-                case 'ErrorObject':
-                    return 'errors';
-                case 'ExamplePairing':
-                    return 'examplePairingObjects';
-                case 'Tag':
-                    return 'tags';
-                default:
-                    return null;
-            }
-    }
-}
-export function makeBundleVisitor({ version, dereference, rootDocument, resolvedRefMap, keepUrlRefs, componentRenamingConflicts = 'warn', }) {
-    let components;
-    let rootLocation;
-    const visitor = {
-        ref: {
-            leave(node, ctx, resolved) {
-                if (!resolved.location || resolved.node === undefined) {
-                    reportUnresolvedRef(resolved, ctx.report, ctx.location);
-                    return;
-                }
-                if (resolved.location.source === rootDocument.source &&
-                    resolved.location.source === ctx.location.source &&
-                    ctx.type.name !== 'scalar' &&
-                    !dereference) {
-                    // Normalize explicit self-file refs to internal pointer
-                    if (node.$ref !== resolved.location.pointer) {
-                        node.$ref = resolved.location.pointer;
-                    }
-                    return;
-                }
-                if (keepUrlRefs && isAbsoluteUrl(node.$ref)) {
-                    return;
-                }
-                const componentType = mapTypeToComponent(ctx.type.name, version);
-                if (!componentType) {
-                    replaceRef(node, resolved, ctx);
-                }
-                else {
-                    if (dereference) {
-                        saveComponent(componentType, resolved, ctx);
-                        replaceRef(node, resolved, ctx);
-                    }
-                    else {
-                        node.$ref = saveComponent(componentType, resolved, ctx);
-                        resolveBundledComponent(node, resolved, ctx);
-                    }
-                }
-            },
-        },
-        Example: {
-            leave(node, ctx) {
-                if (isExternalValue(node) && node.value === undefined) {
-                    const resolved = ctx.resolve({ $ref: node.externalValue });
-                    if (!resolved.location || resolved.node === undefined) {
-                        reportUnresolvedRef(resolved, ctx.report, ctx.location);
-                        return;
-                    }
-                    if (keepUrlRefs && isAbsoluteUrl(node.externalValue)) {
-                        return;
-                    }
-                    node.value = ctx.resolve({ $ref: node.externalValue }).node;
-                    delete node.externalValue;
-                }
-            },
-        },
-        Root: {
-            enter(root, ctx) {
-                rootLocation = ctx.location;
-                if (version === 'oas3') {
-                    components = root.components = root.components || {};
-                }
-                else if (version === 'oas2') {
-                    components = root;
-                }
-                else if (version === 'async2') {
-                    components = root.components = root.components || {};
-                }
-                else if (version === 'async3') {
-                    components = root.components = root.components || {};
-                }
-                else if (version === 'arazzo1') {
-                    components = root.components = root.components || {};
-                }
-                else if (version === 'openrpc1') {
-                    components = root.components = root.components || {};
-                }
-            },
-        },
-    };
-    if (version === 'oas3') {
-        const componentType = mapTypeToComponent('Schema', version);
-        visitor.Discriminator = {
-            leave(discriminator, ctx) {
-                if (typeof discriminator.defaultMapping !== 'string' ||
-                    !isMappingRef(discriminator.defaultMapping)) {
-                    return;
-                }
-                const resolved = ctx.resolve({ $ref: discriminator.defaultMapping });
-                if (!resolved.location || resolved.node === undefined) {
-                    reportUnresolvedRef(resolved, ctx.report, ctx.location.child('defaultMapping'));
-                    return;
-                }
-                discriminator.defaultMapping = saveComponent(componentType, resolved, ctx);
-            },
-            DiscriminatorMapping: {
-                leave(mapping, ctx) {
-                    for (const name of Object.keys(mapping)) {
-                        const $ref = mapping[name];
-                        if (!isMappingRef($ref)) {
-                            continue;
-                        }
-                        const resolved = ctx.resolve({ $ref });
-                        if (!resolved.location || resolved.node === undefined) {
-                            reportUnresolvedRef(resolved, ctx.report, ctx.location.child(name));
-                            return;
-                        }
-                        mapping[name] = saveComponent(componentType, resolved, ctx);
-                    }
-                },
-            },
-        };
-    }
-    function resolveBundledComponent(node, resolved, ctx) {
-        const newRefId = makeRefId(ctx.location.source.absoluteRef, node.$ref);
-        resolvedRefMap.set(newRefId, {
-            document: rootDocument,
-            isRemote: false,
-            node: resolved.node,
-            nodePointer: node.$ref,
-            resolved: true,
-        });
-    }
-    function saveComponent(componentType, target, ctx) {
-        components[componentType] = components[componentType] || {};
-        const name = getComponentName(target, componentType, ctx);
-        components[componentType][name] = target.node;
-        if (version === 'oas3' ||
-            version === 'async2' ||
-            version === 'async3' ||
-            version === 'openrpc1') {
-            return `#/components/${componentType}/${name}`;
-        }
-        else {
-            return `#/${componentType}/${name}`;
-        }
-    }
-    function isEqualOrEqualRef(node, target, ctx) {
-        if (isRef(node) &&
-            ctx.resolve(node, rootLocation.absolutePointer).location?.absolutePointer ===
-                target.location.absolutePointer) {
-            return true;
-        }
-        return dequal(node, target.node);
-    }
-    function getComponentName(target, componentType, ctx) {
-        const componentsGroup = components[componentType];
-        const [fileRef, pointer] = [target.location.source.absoluteRef, target.location.pointer];
-        let name = pointerBaseName(pointer) || refBaseName(fileRef);
-        const prevName = name;
-        let serialId = 2;
-        while (componentsGroup[name] && !isEqualOrEqualRef(componentsGroup[name], target, ctx)) {
-            name = `${prevName}-${serialId}`;
-            serialId++;
-        }
-        if (!componentsGroup[name] && prevName !== name) {
-            ctx.report({
-                message: `Two schemas are referenced with the same name but different content. Renamed ${prevName} to ${name}.`,
-                location: ctx.location,
-                forceSeverity: componentRenamingConflicts,
-            });
-        }
-        return name;
-    }
-    return visitor;
-}
-//# sourceMappingURL=bundle-visitor.js.map