@gitbook/react-openapi 1.1.4 → 1.1.6

package/dist/generateSchemaExample.d.ts

@@ -1,5 +1,4 @@
 import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import { getExampleFromSchema } from '@scalar/oas-utils/spec-getters';
 type JSONValue = string | number | boolean | null | JSONValue[] | {
     [key: string]: JSONValue;
 };
@@ -12,5 +11,35 @@ export declare function generateSchemaExample(schema: OpenAPIV3.SchemaObject, op
 /**
  * Generate an example for a media type.
  */
-export declare function generateMediaTypeExample(mediaType: OpenAPIV3.MediaTypeObject, options?: GenerateSchemaExampleOptions): JSONValue | undefined;
+export declare function generateMediaTypeExamples(mediaType: OpenAPIV3.MediaTypeObject, options?: GenerateSchemaExampleOptions): OpenAPIV3.ExampleObject[];
+/**
+ * This function takes an OpenAPI schema and generates an example from it
+ * Forked from : https://github.com/scalar/scalar/blob/main/packages/oas-utils/src/spec-getters/getExampleFromSchema.ts
+ */
+declare const getExampleFromSchema: (schema: Record<string, any>, options?: {
+    /**
+     * The fallback string for empty string values.
+     * @default ''
+     */
+    emptyString?: string;
+    /**
+     * Whether to use the XML tag names as keys
+     * @default false
+     */
+    xml?: boolean;
+    /**
+     * Whether to show read-only/write-only properties. Otherwise all properties are shown.
+     * @default undefined
+     */
+    mode?: "read" | "write";
+    /**
+     * Dynamic values to add to the example.
+     */
+    variables?: Record<string, any>;
+    /**
+     * Whether to omit empty and optional properties.
+     * @default false
+     */
+    omitEmptyAndOptionalProperties?: boolean;
+}, level?: number, parentSchema?: Record<string, any>, name?: string) => any;
 export {};

package/dist/generateSchemaExample.js

@@ -9,44 +9,327 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { getExampleFromSchema } from '@scalar/oas-utils/spec-getters';
+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));
+};
+var _a, _b, _c;
+import { checkIsReference } from './utils';
 /**
  * Generate a JSON example from a schema
  */
 export function generateSchemaExample(schema, options) {
-    return getExampleFromSchema(schema, __assign({ emptyString: 'text', variables: {
-            'date-time': new Date().toISOString(),
-            date: new Date().toISOString().split('T')[0],
-            email: 'name@gmail.com',
-            hostname: 'example.com',
-            ipv4: '0.0.0.0',
-            ipv6: '2001:0db8:85a3:0000:0000:8a2e:0370:7334',
-            uri: 'https://example.com',
-            uuid: '123e4567-e89b-12d3-a456-426614174000',
-            binary: 'binary',
-            byte: 'Ynl0ZXM=',
-            password: 'password',
-        } }, options), 3 // Max depth for circular references
+    return getExampleFromSchema(schema, __assign({ emptyString: 'text' }, options), 3 // Max depth for circular references
     );
 }
 /**
  * Generate an example for a media type.
  */
-export function generateMediaTypeExample(mediaType, options) {
+export function generateMediaTypeExamples(mediaType, options) {
     if (mediaType.example) {
-        return mediaType.example;
+        return [{ summary: 'default', value: mediaType.example }];
     }
     if (mediaType.examples) {
-        var key = Object.keys(mediaType.examples)[0];
-        if (key) {
-            var example = mediaType.examples[key];
-            if (example) {
-                return example.value;
-            }
+        var examples_1 = mediaType.examples;
+        var keys = Object.keys(examples_1);
+        if (keys.length > 0) {
+            return keys.reduce(function (result, key) {
+                var example = examples_1[key];
+                if (!example || checkIsReference(example)) {
+                    return result;
+                }
+                result.push({
+                    summary: example.summary || key,
+                    value: example.value,
+                    description: example.description,
+                    externalValue: example.externalValue,
+                });
+                return result;
+            }, []);
         }
     }
     if (mediaType.schema) {
-        return generateSchemaExample(mediaType.schema, options);
+        return [{ summary: 'default', value: generateSchemaExample(mediaType.schema, options) }];
     }
-    return undefined;
+    return [];
 }
+/** Hard limit for rendering circular references */
+var MAX_LEVELS_DEEP = 5;
+var genericExampleValues = {
+    'date-time': new Date().toISOString(),
+    date: (_a = new Date().toISOString().split('T')[0]) !== null && _a !== void 0 ? _a : '1970-01-01',
+    email: 'name@gmail.com',
+    hostname: 'example.com',
+    ipv4: '0.0.0.0',
+    ipv6: '2001:0db8:85a3:0000:0000:8a2e:0370:7334',
+    uri: 'https://example.com',
+    uuid: '123e4567-e89b-12d3-a456-426614174000',
+    binary: 'binary',
+    byte: 'Ynl0ZXM=',
+    password: 'password',
+    'idn-email': 'jane.doe@example.com',
+    'idn-hostname': 'example.com',
+    'iri-reference': '/entitiy/1',
+    // https://tools.ietf.org/html/rfc3987
+    iri: 'https://example.com/entity/123',
+    'json-pointer': '/nested/objects',
+    regex: '/[a-z]/',
+    // https://tools.ietf.org/html/draft-handrews-relative-json-pointer-01
+    'relative-json-pointer': '1/nested/objects',
+    // full-time in https://tools.ietf.org/html/rfc3339#section-5.6
+    time: (_c = (_b = new Date().toISOString().split('T')[1]) === null || _b === void 0 ? void 0 : _b.split('.')[0]) !== null && _c !== void 0 ? _c : '00:00:00Z',
+    // either a URI or relative-reference https://tools.ietf.org/html/rfc3986#section-4.1
+    'uri-reference': '../folder',
+    'uri-template': 'https://example.com/{id}',
+    'object-id': '6592008029c8c3e4dc76256c',
+};
+/**
+ * We can use the `format` to generate some random values.
+ */
+function guessFromFormat(schema, fallback) {
+    var _a;
+    if (fallback === void 0) { fallback = ''; }
+    return (_a = genericExampleValues[schema.format]) !== null && _a !== void 0 ? _a : fallback;
+}
+/** Map of all the results */
+var resultCache = new WeakMap();
+/** Store result in the cache, and return the result */
+function cache(schema, result) {
+    // Avoid unnecessary WeakMap operations for primitive values
+    if (typeof result !== 'object' || result === null) {
+        return result;
+    }
+    resultCache.set(schema, result);
+    return result;
+}
+/**
+ * This function takes an OpenAPI schema and generates an example from it
+ * Forked from : https://github.com/scalar/scalar/blob/main/packages/oas-utils/src/spec-getters/getExampleFromSchema.ts
+ */
+var getExampleFromSchema = function (schema, options, level, parentSchema, name) {
+    var _a, _b, _c, _d;
+    var _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+    if (level === void 0) { level = 0; }
+    // Check if the result is already cached
+    if (resultCache.has(schema)) {
+        return resultCache.get(schema);
+    }
+    // Check whether it’s a circular reference
+    if (level === MAX_LEVELS_DEEP + 1) {
+        try {
+            // Fails if it contains a circular reference
+            JSON.stringify(schema);
+        }
+        catch (_v) {
+            return '[Circular Reference]';
+        }
+    }
+    // Sometimes, we just want the structure and no values.
+    // But if `emptyString` is  set, we do want to see some values.
+    var makeUpRandomData = !!(options === null || options === void 0 ? void 0 : options.emptyString);
+    // Check if the property is read-only/write-only
+    if (((options === null || options === void 0 ? void 0 : options.mode) === 'write' && schema.readOnly) ||
+        ((options === null || options === void 0 ? void 0 : options.mode) === 'read' && schema.writeOnly)) {
+        return undefined;
+    }
+    // Use given variables as values
+    if (schema['x-variable']) {
+        var value = (_e = options === null || options === void 0 ? void 0 : options.variables) === null || _e === void 0 ? void 0 : _e[schema['x-variable']];
+        // Return the value if it’s defined
+        if (value !== undefined) {
+            // Type-casting
+            if (schema.type === 'number' || schema.type === 'integer') {
+                return Number.parseInt(value, 10);
+            }
+            return cache(schema, value);
+        }
+    }
+    // Use the first example, if there’s an array
+    if (Array.isArray(schema.examples) && schema.examples.length > 0) {
+        return cache(schema, schema.examples[0]);
+    }
+    // Use an example, if there’s one
+    if (schema.example !== undefined) {
+        return cache(schema, schema.example);
+    }
+    // enum: [ 'available', 'pending', 'sold' ]
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+        return cache(schema, schema.enum[0]);
+    }
+    // Check if the property is required
+    var isObjectOrArray = schema.type === 'object' ||
+        schema.type === 'array' ||
+        !!((_g = (_f = schema.allOf) === null || _f === void 0 ? void 0 : _f.at) === null || _g === void 0 ? void 0 : _g.call(_f, 0)) ||
+        !!((_j = (_h = schema.anyOf) === null || _h === void 0 ? void 0 : _h.at) === null || _j === void 0 ? void 0 : _j.call(_h, 0)) ||
+        !!((_l = (_k = schema.oneOf) === null || _k === void 0 ? void 0 : _k.at) === null || _l === void 0 ? void 0 : _l.call(_k, 0));
+    if (!isObjectOrArray && (options === null || options === void 0 ? void 0 : options.omitEmptyAndOptionalProperties) === true) {
+        var isRequired = schema.required === true ||
+            (parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.required) === true ||
+            ((_m = parentSchema === null || parentSchema === void 0 ? void 0 : parentSchema.required) === null || _m === void 0 ? void 0 : _m.includes(name !== null && name !== void 0 ? name : schema.name));
+        if (!isRequired) {
+            return undefined;
+        }
+    }
+    // Object
+    if (schema.type === 'object' || schema.properties !== undefined) {
+        var response = {};
+        // Regular properties
+        if (schema.properties !== undefined) {
+            for (var propertyName in schema.properties) {
+                if (Object.prototype.hasOwnProperty.call(schema.properties, propertyName)) {
+                    var property = schema.properties[propertyName];
+                    var propertyXmlTagName = (options === null || options === void 0 ? void 0 : options.xml) ? (_o = property.xml) === null || _o === void 0 ? void 0 : _o.name : undefined;
+                    response[propertyXmlTagName !== null && propertyXmlTagName !== void 0 ? propertyXmlTagName : propertyName] = getExampleFromSchema(property, options, level + 1, schema, propertyName);
+                    if (typeof response[propertyXmlTagName !== null && propertyXmlTagName !== void 0 ? propertyXmlTagName : propertyName] === 'undefined') {
+                        delete response[propertyXmlTagName !== null && propertyXmlTagName !== void 0 ? propertyXmlTagName : propertyName];
+                    }
+                }
+            }
+        }
+        // Pattern properties (regex)
+        if (schema.patternProperties !== undefined) {
+            for (var pattern in schema.patternProperties) {
+                if (Object.prototype.hasOwnProperty.call(schema.patternProperties, pattern)) {
+                    var property = schema.patternProperties[pattern];
+                    // Use the regex pattern as an example key
+                    var exampleKey = pattern;
+                    response[exampleKey] = getExampleFromSchema(property, options, level + 1, schema, exampleKey);
+                }
+            }
+        }
+        // Additional properties
+        if (schema.additionalProperties !== undefined) {
+            var anyTypeIsValid = 
+            // true
+            schema.additionalProperties === true ||
+                // or an empty object {}
+                (typeof schema.additionalProperties === 'object' &&
+                    !Object.keys(schema.additionalProperties).length);
+            if (anyTypeIsValid) {
+                response.ANY_ADDITIONAL_PROPERTY = 'anything';
+            }
+            else if (schema.additionalProperties !== false) {
+                response.ANY_ADDITIONAL_PROPERTY = getExampleFromSchema(schema.additionalProperties, options, level + 1);
+            }
+        }
+        if (schema.anyOf !== undefined) {
+            Object.assign(response, getExampleFromSchema(schema.anyOf[0], options, level + 1));
+        }
+        else if (schema.oneOf !== undefined) {
+            Object.assign(response, getExampleFromSchema(schema.oneOf[0], options, level + 1));
+        }
+        else if (schema.allOf !== undefined) {
+            Object.assign.apply(Object, __spreadArray([response], schema.allOf
+                .map(function (item) {
+                return getExampleFromSchema(item, options, level + 1, schema);
+            })
+                .filter(function (item) { return item !== undefined; }), false));
+        }
+        return cache(schema, response);
+    }
+    // Array
+    if (schema.type === 'array' || schema.items !== undefined) {
+        var itemsXmlTagName_1 = (_q = (_p = schema === null || schema === void 0 ? void 0 : schema.items) === null || _p === void 0 ? void 0 : _p.xml) === null || _q === void 0 ? void 0 : _q.name;
+        var wrapItems = !!((options === null || options === void 0 ? void 0 : options.xml) && ((_r = schema.xml) === null || _r === void 0 ? void 0 : _r.wrapped) && itemsXmlTagName_1);
+        if (schema.example !== undefined) {
+            return cache(schema, wrapItems ? (_a = {}, _a[itemsXmlTagName_1] = schema.example, _a) : schema.example);
+        }
+        // Check whether the array has a anyOf, oneOf, or allOf rule
+        if (schema.items) {
+            // First handle allOf separately since it needs special handling
+            if (schema.items.allOf) {
+                // If the first item is an object type, merge all schemas
+                if (schema.items.allOf[0].type === 'object') {
+                    var mergedExample = getExampleFromSchema({ type: 'object', allOf: schema.items.allOf }, options, level + 1, schema);
+                    return cache(schema, wrapItems ? [(_b = {}, _b[itemsXmlTagName_1] = mergedExample, _b)] : [mergedExample]);
+                }
+                // For non-objects (like strings), collect all examples
+                var examples = schema.items.allOf
+                    .map(function (item) {
+                    return getExampleFromSchema(item, options, level + 1, schema);
+                })
+                    .filter(function (item) { return item !== undefined; });
+                return cache(schema, wrapItems
+                    ? examples.map(function (example) {
+                        var _a;
+                        return (_a = {}, _a[itemsXmlTagName_1] = example, _a);
+                    })
+                    : examples);
+            }
+            // Handle other rules (anyOf, oneOf)
+            var rules = ['anyOf', 'oneOf'];
+            for (var _i = 0, rules_1 = rules; _i < rules_1.length; _i++) {
+                var rule = rules_1[_i];
+                if (!schema.items[rule]) {
+                    continue;
+                }
+                var schemas = schema.items[rule].slice(0, 1);
+                var exampleFromRule = schemas
+                    .map(function (item) {
+                    return getExampleFromSchema(item, options, level + 1, schema);
+                })
+                    .filter(function (item) { return item !== undefined; });
+                return cache(schema, wrapItems ? [(_c = {}, _c[itemsXmlTagName_1] = exampleFromRule, _c)] : exampleFromRule);
+            }
+        }
+        if ((_s = schema.items) === null || _s === void 0 ? void 0 : _s.type) {
+            var exampleFromSchema = getExampleFromSchema(schema.items, options, level + 1);
+            return wrapItems ? [(_d = {}, _d[itemsXmlTagName_1] = exampleFromSchema, _d)] : [exampleFromSchema];
+        }
+        return [];
+    }
+    var exampleValues = {
+        string: makeUpRandomData ? guessFromFormat(schema, options === null || options === void 0 ? void 0 : options.emptyString) : '',
+        boolean: true,
+        integer: (_t = schema.min) !== null && _t !== void 0 ? _t : 1,
+        number: (_u = schema.min) !== null && _u !== void 0 ? _u : 1,
+        array: [],
+    };
+    if (schema.type !== undefined && exampleValues[schema.type] !== undefined) {
+        return cache(schema, exampleValues[schema.type]);
+    }
+    var discriminateSchema = schema.oneOf || schema.anyOf;
+    // Check if property has the `oneOf` | `anyOf` key
+    if (Array.isArray(discriminateSchema) && discriminateSchema.length > 0) {
+        // Get the first item from the `oneOf` | `anyOf` array
+        var firstOneOfItem = discriminateSchema[0];
+        // Return an example for the first item
+        return getExampleFromSchema(firstOneOfItem, options, level + 1);
+    }
+    // Check if schema has the `allOf` key
+    if (Array.isArray(schema.allOf)) {
+        var example_1 = null;
+        // Loop through all `allOf` schemas
+        schema.allOf.forEach(function (allOfItem) {
+            // Return an example from the schema
+            var newExample = getExampleFromSchema(allOfItem, options, level + 1);
+            // Merge or overwrite the example
+            example_1 =
+                typeof newExample === 'object' && typeof example_1 === 'object'
+                    ? __assign(__assign({}, (example_1 !== null && example_1 !== void 0 ? example_1 : {})), newExample) : Array.isArray(newExample) && Array.isArray(example_1)
+                    ? __spreadArray(__spreadArray([], (example_1 !== null && example_1 !== void 0 ? example_1 : {}), true), newExample, true) : newExample;
+        });
+        return cache(schema, example_1);
+    }
+    // Check if schema is a union type
+    if (Array.isArray(schema.type)) {
+        // Return null if the type is nullable
+        if (schema.type.includes('null')) {
+            return null;
+        }
+        // Return an example for the first type in the union
+        var exampleValue = exampleValues[schema.type[0]];
+        if (exampleValue !== undefined) {
+            return cache(schema, exampleValue);
+        }
+    }
+    // Warn if the type is unknown …
+    // console.warn(`[getExampleFromSchema] Unknown property type "${schema.type}".`)
+    // … and just return null for now.
+    return null;
+};