@kubb/agent 4.27.2 → 4.27.4

package/.output/server/node_modules/@redocly/openapi-core/lib/types/json-schema-adapter.js

@@ -1,174 +0,0 @@
-// For internal usage only
-import Ajv from '@redocly/ajv/dist/2020.js';
-import { isPlainObject } from '../utils/is-plain-object.js';
-const ajv = new Ajv({
-    strictSchema: false,
-    allowUnionTypes: true,
-    useDefaults: true,
-    allErrors: true,
-    discriminator: true,
-    strictTypes: false,
-    verbose: true,
-});
-function findOneOf(schemaOneOf, oneOfs) {
-    if (oneOfs.some((option) => typeof option === 'function')) {
-        throw new Error('Unexpected oneOf inside oneOf.');
-    }
-    return (value) => {
-        let index = schemaOneOf.findIndex((option) => ajv.validate(option, value));
-        if (index === -1) {
-            index = 0;
-        }
-        return oneOfs[index];
-    };
-}
-function transformJSONSchemaToNodeType(propertyName, schema, ctx) {
-    if (!schema || typeof schema === 'boolean') {
-        throw new Error(`Unexpected schema in ${propertyName}.`);
-    }
-    if (schema instanceof Array) {
-        throw new Error(`Unexpected array schema in ${propertyName}. Try using oneOf instead.`);
-    }
-    if (schema.type === 'null') {
-        throw new Error(`Unexpected null schema type in ${propertyName} schema.`);
-    }
-    if (schema.type instanceof Array) {
-        throw new Error(`Unexpected array schema type in ${propertyName} schema. Try using oneOf instead.`);
-    }
-    if (schema.type === 'string' ||
-        schema.type === 'number' ||
-        schema.type === 'integer' ||
-        schema.type === 'boolean') {
-        const { default: _, format: _format, ...rest } = schema;
-        return rest;
-    }
-    if (schema.type === 'object' && !schema.properties && !schema.oneOf) {
-        if (schema.additionalProperties === undefined || schema.additionalProperties === true) {
-            return { type: 'object' };
-        }
-        else if (schema.additionalProperties === false) {
-            return { type: 'object', properties: {} };
-        }
-    }
-    if (schema.allOf) {
-        throw new Error(`Unexpected allOf in ${propertyName}.`);
-    }
-    if (schema.anyOf) {
-        throw new Error(`Unexpected anyOf in ${propertyName}.`);
-    }
-    if (isPlainObject(schema.properties) ||
-        isPlainObject(schema.additionalProperties) ||
-        (isPlainObject(schema.items) &&
-            (isPlainObject(schema.items.properties) ||
-                isPlainObject(schema.items.additionalProperties) ||
-                schema.items.oneOf)) // exclude scalar array types
-    ) {
-        return extractNodeToContext(propertyName, schema, ctx);
-    }
-    if (schema.oneOf) {
-        if (schema.discriminator) {
-            const discriminatedPropertyName = schema.discriminator?.propertyName;
-            if (!discriminatedPropertyName) {
-                throw new Error(`Unexpected discriminator without a propertyName in ${propertyName}.`);
-            }
-            // Map discriminator values to their actual type names
-            const discriminatorMapping = {};
-            const oneOfs = schema.oneOf.map((option, i) => {
-                if (typeof option === 'boolean') {
-                    throw new Error(`Unexpected boolean schema in ${propertyName} at position ${i} in oneOf.`);
-                }
-                const discriminatedProperty = option?.properties?.[discriminatedPropertyName];
-                if (!discriminatedProperty || typeof discriminatedProperty === 'boolean') {
-                    throw new Error(`Unexpected property '${discriminatedProperty}' schema in ${propertyName} at position ${i} in oneOf.`);
-                }
-                const discriminatorValue = discriminatedProperty.const;
-                const actualTypeName = transformJSONSchemaToNodeType(discriminatorValue, option, ctx);
-                // Store mapping from discriminator value to actual type name
-                if (typeof actualTypeName === 'string') {
-                    discriminatorMapping[discriminatorValue] = actualTypeName;
-                }
-                return actualTypeName;
-            });
-            //TODO: investigate why this function doesn't invoke inside the current function scope
-            return (value, key) => {
-                if (isPlainObject(value)) {
-                    const discriminatedTypeName = value[discriminatedPropertyName];
-                    if (typeof discriminatedTypeName === 'string') {
-                        const actualTypeName = discriminatorMapping[discriminatedTypeName];
-                        if (actualTypeName && ctx[actualTypeName]) {
-                            return actualTypeName;
-                        }
-                    }
-                }
-                return findOneOf(schema.oneOf, oneOfs)(value, key);
-            };
-        }
-        else {
-            const oneOfs = schema.oneOf.map((option, i) => transformJSONSchemaToNodeType(propertyName + '_' + i, option, ctx));
-            return findOneOf(schema.oneOf, oneOfs);
-        }
-    }
-    return schema;
-}
-function extractNodeToContext(propertyName, schema, ctx) {
-    if (!schema || typeof schema === 'boolean') {
-        throw new Error(`Unexpected schema in ${propertyName}.`);
-    }
-    if (schema instanceof Array) {
-        throw new Error(`Unexpected array schema in ${propertyName}. Try using oneOf instead.`);
-    }
-    if (schema.type === 'null') {
-        throw new Error(`Unexpected null schema type in ${propertyName} schema.`);
-    }
-    if (schema.type instanceof Array) {
-        throw new Error(`Unexpected array schema type in ${propertyName} schema. Try using oneOf instead.`);
-    }
-    // Use nodeTypeName from schema if provided, otherwise use propertyName
-    const nodeTypeName = schema['nodeTypeName'] ?? propertyName;
-    const properties = {};
-    for (const [name, property] of Object.entries(schema.properties || {})) {
-        properties[name] = transformJSONSchemaToNodeType(nodeTypeName + '.' + name, property, ctx);
-    }
-    let additionalProperties;
-    if (isPlainObject(schema.additionalProperties)) {
-        additionalProperties = transformJSONSchemaToNodeType(propertyName + '_additionalProperties', schema.additionalProperties, ctx);
-    }
-    if (schema.additionalProperties === true) {
-        additionalProperties = {};
-    }
-    let items;
-    if (isPlainObject(schema.items) &&
-        (isPlainObject(schema.items.properties) ||
-            isPlainObject(schema.items.additionalProperties) ||
-            schema.items.oneOf) // exclude scalar array types
-    ) {
-        items = transformJSONSchemaToNodeType(propertyName + '_items', schema.items, ctx);
-    }
-    let required = schema.required;
-    // Translate required in oneOfs into a ResolveTypeFn.
-    if (schema.oneOf && schema.oneOf.every((option) => !!option.required)) {
-        required = (value) => {
-            const requiredList = schema.oneOf.map((option) => [
-                ...(schema.required || []),
-                ...option.required,
-            ]);
-            let index = requiredList.findIndex((r) => r.every((requiredProp) => value[requiredProp] !== undefined));
-            if (index === -1) {
-                index = 0;
-            }
-            return requiredList[index];
-        };
-    }
-    ctx[nodeTypeName] = { properties, additionalProperties, items, required };
-    return nodeTypeName;
-}
-export function getNodeTypesFromJSONSchema(schemaName, entrySchema) {
-    const ctx = {};
-    //TODO: fix this function to return discriminator resolvers in all NodeTypes that are returned in ctx. Currently it only only returns one discriminatorResolver for all types.
-    const discriminatorResolver = transformJSONSchemaToNodeType(schemaName, entrySchema, ctx);
-    return {
-        ctx,
-        discriminatorResolver: typeof discriminatorResolver === 'function' ? discriminatorResolver : undefined,
-    };
-}
-//# sourceMappingURL=json-schema-adapter.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/types/json-schema-draft7.shared.js

@@ -1,101 +0,0 @@
-import { isMappingRef } from '../ref-utils.js';
-import { listOf } from './index.js';
-export const Schema = {
-    properties: {
-        $id: { type: 'string' },
-        $schema: { type: 'string' },
-        definitions: 'NamedSchemas',
-        externalDocs: 'ExternalDocs',
-        discriminator: 'Discriminator',
-        title: { type: 'string' },
-        multipleOf: { type: 'number', minimum: 0 },
-        maximum: { type: 'number' },
-        minimum: { type: 'number' },
-        exclusiveMaximum: { type: 'number' },
-        exclusiveMinimum: { type: 'number' },
-        maxLength: { type: 'integer', minimum: 0 },
-        minLength: { type: 'integer', minimum: 0 },
-        pattern: { type: 'string' },
-        maxItems: { type: 'integer', minimum: 0 },
-        minItems: { type: 'integer', minimum: 0 },
-        uniqueItems: { type: 'boolean' },
-        maxProperties: { type: 'integer', minimum: 0 },
-        minProperties: { type: 'integer', minimum: 0 },
-        required: { type: 'array', items: { type: 'string' } },
-        enum: { type: 'array' },
-        type: (value) => {
-            return Array.isArray(value)
-                ? {
-                    type: 'array',
-                    items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] },
-                }
-                : {
-                    enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
-                };
-        },
-        allOf: listOf('Schema'),
-        anyOf: listOf('Schema'),
-        oneOf: listOf('Schema'),
-        not: 'Schema',
-        if: 'Schema',
-        then: 'Schema',
-        else: 'Schema',
-        contains: 'Schema',
-        patternProperties: { type: 'object' },
-        propertyNames: 'Schema',
-        properties: 'SchemaProperties',
-        items: (value) => {
-            return Array.isArray(value) ? listOf('Schema') : 'Schema';
-        },
-        additionalProperties: (value) => {
-            return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
-        },
-        description: { type: 'string' },
-        format: { type: 'string' },
-        contentEncoding: { type: 'string' },
-        contentMediaType: { type: 'string' },
-        default: null,
-        readOnly: { type: 'boolean' },
-        writeOnly: { type: 'boolean' },
-        examples: { type: 'array' },
-        example: { isExample: true },
-        deprecated: { type: 'boolean' },
-        const: null,
-        $comment: { type: 'string' },
-        additionalItems: (value) => {
-            return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
-        },
-        dependencies: 'Dependencies',
-    },
-};
-export const SchemaProperties = {
-    properties: {},
-    additionalProperties: (value) => {
-        return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
-    },
-};
-export const Dependencies = {
-    properties: {},
-    additionalProperties: (value) => {
-        return Array.isArray(value) ? { type: 'array', items: { type: 'string' } } : 'Schema';
-    },
-};
-export const DiscriminatorMapping = {
-    properties: {},
-    additionalProperties: (value) => {
-        if (isMappingRef(value)) {
-            return { type: 'string', directResolveAs: 'Schema' };
-        }
-        else {
-            return { type: 'string' };
-        }
-    },
-};
-export const Discriminator = {
-    properties: {
-        propertyName: { type: 'string' },
-        mapping: 'DiscriminatorMapping',
-    },
-    required: ['propertyName'],
-};
-//# sourceMappingURL=json-schema-draft7.shared.js.map