openapi-explorer 0.9.310 → 0.9.314

package/dist/lib/utils/schema-utils.js

@@ -0,0 +1,743 @@
+"use strict";
+
+exports.__esModule = true;
+exports.generateExample = generateExample;
+exports.getExampleValuesFromSchema = getExampleValuesFromSchema;
+exports.getSampleValueByType = getSampleValueByType;
+exports.getTypeInfo = getTypeInfo;
+exports.schemaInObjectNotation = schemaInObjectNotation;
+
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+
+var _regexToStrings = require("regex-to-strings");
+
+var _xml = _interopRequireDefault(require("./xml/xml"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// When the type is not known for a property set the displayed type to be this:
+const IS_MISSING_TYPE_INFO_TYPE = '';
+/* Generates an schema object containing type and constraint info */
+
+function getTypeInfo(schema) {
+  if (!schema) {
+    return undefined;
+  }
+
+  let dataType = '';
+  let constraint = '';
+
+  if (schema.$ref) {
+    const n = schema.$ref.lastIndexOf('/');
+    const schemaNode = schema.$ref.substring(n + 1);
+    dataType = `{recursive: ${schemaNode}} `;
+  } else if (schema.type) {
+    const arraySchema = Array.isArray(schema.type) ? schema.type : typeof schema.type === 'string' ? schema.type.split('┃') : schema.type;
+    dataType = Array.isArray(arraySchema) ? arraySchema.filter(s => s !== 'null').join('┃') : schema.type;
+
+    if (schema.format || schema.enum) {
+      dataType = dataType.replace('string', schema.enum ? 'enum' : schema.format);
+    }
+  } else {
+    dataType = IS_MISSING_TYPE_INFO_TYPE;
+  }
+
+  const info = {
+    type: dataType,
+    format: schema.format || '',
+    pattern: schema.pattern && !schema.enum ? schema.pattern : '',
+    readOrWriteOnly: schema.readOnly && '🆁' || schema.writeOnly && '🆆' || '',
+    deprecated: !!schema.deprecated,
+    example: Array.isArray(schema.example) ? schema.example : typeof schema.example !== 'undefined' ? `${schema.example}` : '',
+    default: schema.default || '',
+    title: schema.title || '',
+    description: schema.description || '',
+    constraint: '',
+    allowedValues: '',
+    arrayType: '',
+    html: ''
+  };
+
+  if (info.type === '{recursive}') {
+    info.description = schema.$ref.substring(schema.$ref.lastIndexOf('/') + 1);
+  } else if (info.type === IS_MISSING_TYPE_INFO_TYPE) {
+    info.description = info.description || '';
+  } // Set Allowed Values
+
+
+  info.allowedValues = Array.isArray(schema.enum) ? schema.enum.join('┃') : '';
+
+  if (dataType === 'array' && schema.items) {
+    var _schema$items$default;
+
+    const arrayItemType = schema.items.type;
+    const arrayItemDefault = (_schema$items$default = schema.items.default) !== null && _schema$items$default !== void 0 ? _schema$items$default : '';
+    info.arrayType = `${schema.type} of ${Array.isArray(arrayItemType) ? arrayItemType.join('') : arrayItemType}`;
+    info.default = arrayItemDefault;
+    info.allowedValues = Array.isArray(schema.items.enum) ? schema.items.enum.join('┃') : '';
+  }
+
+  if (dataType.match(/integer|number/g)) {
+    var _schema$minimum, _schema$maximum;
+
+    const minimum = (_schema$minimum = schema.minimum) !== null && _schema$minimum !== void 0 ? _schema$minimum : schema.exclusiveMinimum;
+    const maximum = (_schema$maximum = schema.maximum) !== null && _schema$maximum !== void 0 ? _schema$maximum : schema.exclusiveMaximum;
+    const leftBound = schema.minimum !== undefined ? '[' : '(';
+    const rightBound = schema.maximum !== undefined ? ']' : ')';
+
+    if (typeof minimum === 'number' || typeof maximum === 'number') {
+      constraint = `Range: ${leftBound}${minimum !== null && minimum !== void 0 ? minimum : ''},${maximum !== null && maximum !== void 0 ? maximum : ''}${rightBound}`;
+    }
+
+    if (schema.multipleOf !== undefined) {
+      constraint += `${constraint ? ', ' : ''}Multiples: ${schema.multipleOf}`;
+    }
+  }
+
+  if (dataType.match(/string/g)) {
+    if (schema.minLength !== undefined && schema.maxLength !== undefined) {
+      constraint += `Min length: ${schema.minLength}, Max length: ${schema.maxLength}`;
+    } else if (schema.minLength !== undefined) {
+      constraint += `Min length: ${schema.minLength}`;
+    } else if (schema.maxLength !== undefined) {
+      constraint += `Max length: ${schema.maxLength}`;
+    }
+  }
+
+  info.constraint = constraint;
+  info.html = JSON.stringify({
+    type: info.type,
+    readOrWriteOnly: info.readOrWriteOnly,
+    constraint: info.constraint,
+    defaultValue: info.default,
+    allowedValues: info.allowedValues,
+    pattern: info.pattern,
+    schemaDescription: info.description,
+    schemaTitle: info.title,
+    deprecated: info.deprecated
+  });
+  return info;
+}
+
+function getSampleValueByType(schemaObj, fallbackPropertyName, skipExampleStrings) {
+  var _schemaObj$type;
+
+  const example = schemaObj.examples ? schemaObj.examples[0] : schemaObj.example;
+
+  if (example === '') {
+    return '';
+  }
+
+  if (example === null) {
+    return null;
+  }
+
+  if (example === 0) {
+    return 0;
+  }
+
+  if (skipExampleStrings && typeof example === 'string') {
+    return '';
+  }
+
+  if (example) {
+    return example;
+  }
+
+  if (schemaObj.default) {
+    return schemaObj.default;
+  }
+
+  if (Object.keys(schemaObj).length === 0) {
+    return null;
+  }
+
+  if (schemaObj.$ref) {
+    // Indicates a Circular ref
+    return schemaObj.$ref;
+  }
+
+  const typeValue = Array.isArray(schemaObj.type) ? schemaObj.type.filter(t => t !== 'null')[0] : (_schemaObj$type = schemaObj.type) !== null && _schemaObj$type !== void 0 ? _schemaObj$type : '';
+
+  if (typeValue.match(/^integer|^number/g)) {
+    const multipleOf = Number.isNaN(Number(schemaObj.multipleOf)) ? undefined : Number(schemaObj.multipleOf);
+    const maximum = Number.isNaN(Number(schemaObj.maximum)) ? undefined : Number(schemaObj.maximum);
+    const minimumPossibleVal = Number.isNaN(Number(schemaObj.minimum)) ? Number.isNaN(Number(schemaObj.exclusiveMinimum)) ? maximum || 0 : Number(schemaObj.exclusiveMinimum) + (typeValue.startsWith('integer') ? 1 : 0.001) : Number(schemaObj.minimum);
+    const finalVal = multipleOf ? multipleOf >= minimumPossibleVal ? multipleOf : minimumPossibleVal % multipleOf === 0 ? minimumPossibleVal : Math.ceil(minimumPossibleVal / multipleOf) * multipleOf : minimumPossibleVal;
+    return finalVal;
+  }
+
+  if (typeValue.match(/^boolean/g)) {
+    return false;
+  }
+
+  if (typeValue.match(/^null/g)) {
+    return null;
+  }
+
+  if (skipExampleStrings && typeValue.match(/^string/g)) {
+    return '';
+  }
+
+  if (typeValue.match(/^string/g)) {
+    if (schemaObj.enum) {
+      return schemaObj.enum[0];
+    }
+
+    if (schemaObj.pattern) {
+      const examplePattern = schemaObj.pattern.replace(/[+*](?![^\][]*[\]])/g, '{8}').replace(/\{\d*,(\d+)?\}/g, '{8}');
+      return (0, _regexToStrings.expandN)(examplePattern, 1)[0] || fallbackPropertyName || 'string';
+    }
+
+    if (schemaObj.format) {
+      switch (schemaObj.format.toLowerCase()) {
+        case 'url':
+          return 'https://example.com';
+
+        case 'uri':
+          return 'urn:namespace:type:example/resource';
+
+        case 'date':
+          return new Date().toISOString().split('T')[0];
+
+        case 'time':
+          return new Date().toISOString().split('T')[1];
+
+        case 'date-time':
+          return new Date().toISOString();
+
+        case 'duration':
+          return 'P3Y6M4DT12H30M5S';
+        // P=Period 3-Years 6-Months 4-Days 12-Hours 30-Minutes 5-Seconds
+
+        case 'email':
+        case 'idn-email':
+          return 'user@example.com';
+
+        case 'hostname':
+        case 'idn-hostname':
+          return 'www.example.com';
+
+        case 'ipv4':
+          return '192.168.0.1';
+
+        case 'ipv6':
+          return '2001:0db8:5b96:0000:0000:426f:8e17:642a';
+
+        case 'uuid':
+          return '4e0ba220-9575-11eb-a8b3-0242ac130003';
+
+        default:
+          return schemaObj.format;
+      }
+    } else {
+      return fallbackPropertyName || 'string';
+    }
+  } // If type cannot be determined
+
+
+  return '?';
+}
+
+function duplicateExampleWithNewPropertyValues(objectExamples, propertyName, propertyValues) {
+  // Limit max number of property examples to 2 and limit the max number of examples to 10
+  return objectExamples.reduce((exampleList, example) => {
+    const examplesFromPropertyValues = propertyValues.slice(0, 2).map(value => ({ ...(0, _lodash.default)(example),
+      [propertyName]: value
+    }));
+    return exampleList.concat(...examplesFromPropertyValues);
+  }, []).slice(0, 10);
+}
+
+function getExampleValuesFromSchema(schema, config = {}) {
+  // Wrap the top level so that the recursive object can treat it as a normal property and we'll hit the 'object' below, otherwise we'll never create the top level.
+  if (config.xml) {
+    const xmlResult = getExampleValuesFromSchemaRecursive(schema.type === 'object' ? {
+      properties: {
+        _root: schema
+      }
+    } : schema, config);
+    return xmlResult.map(example => example[0]);
+  }
+
+  return getExampleValuesFromSchemaRecursive(schema, config);
+} // TODO: Support getting the `summary` from the examples object or the `title` from the schema object
+
+
+function getExampleValuesFromSchemaRecursive(schema, config = {}) {
+  if (!schema) {
+    return [];
+  } // XML Support
+
+
+  const xmlAttributes = {};
+  const xmlTagProperties = [];
+  const {
+    prefix,
+    namespace
+  } = schema.xml || {};
+
+  if (namespace) {
+    xmlAttributes[prefix ? `xmlns:${prefix}` : 'xmlns'] = namespace;
+  }
+
+  const nodeName = schema.items && schema.items.xml && schema.items.xml.name || schema.xml && schema.xml.name || config.propertyName || 'root';
+  const overridePropertyName = prefix ? `${prefix}:${nodeName}` : nodeName;
+
+  if (schema.allOf) {
+    // TODO: allOf support should include merging the schemas together
+    return getExampleValuesFromSchemaRecursive(schema.allOf[0], config);
+  }
+
+  if (schema.oneOf) {
+    return schema.oneOf.map(s => getExampleValuesFromSchemaRecursive(s, config)).flat(1);
+  }
+
+  if (schema.anyOf) {
+    return schema.anyOf.map(s => getExampleValuesFromSchemaRecursive(s, config)).flat(1);
+  }
+
+  if (schema.type === 'array' || schema.items) {
+    if (!config.xml) {
+      return [getExampleValuesFromSchemaRecursive(schema.items || {}, config)];
+    }
+
+    if (!schema.xml || !schema.xml.wrapped) {
+      const arrayExamples = getExampleValuesFromSchemaRecursive(schema.items || {}, config);
+      xmlTagProperties.push({
+        [overridePropertyName]: arrayExamples[0]
+      }, {
+        _attr: xmlAttributes
+      });
+      return [xmlTagProperties];
+    }
+
+    const arrayExamples = getExampleValuesFromSchemaRecursive(schema.items || {}, { ...config,
+      propertyName: overridePropertyName
+    });
+    xmlTagProperties.push({
+      [overridePropertyName]: arrayExamples[0]
+    }, {
+      _attr: xmlAttributes
+    });
+    return [xmlTagProperties];
+  }
+
+  if (schema.type === 'object' || schema.properties) {
+    let objectExamples = [{}];
+    Object.keys(schema.properties || {}).forEach(propertyName => {
+      const innerSchema = schema.properties[propertyName];
+
+      if (innerSchema.deprecated) {
+        return;
+      }
+
+      if (innerSchema.readOnly && !config.includeReadOnly) {
+        return;
+      }
+
+      if (innerSchema.writeOnly && !config.includeWriteOnly) {
+        return;
+      }
+
+      const propertyExamples = getExampleValuesFromSchemaRecursive(innerSchema, { ...config,
+        propertyName
+      });
+      objectExamples = duplicateExampleWithNewPropertyValues(objectExamples, propertyName, propertyExamples);
+
+      if (innerSchema.xml && innerSchema.xml.namespace) {
+        xmlAttributes[innerSchema.xml.prefix ? `xmlns:${innerSchema.xml.prefix}` : 'xmlns'] = namespace;
+      }
+
+      const innerNodeName = innerSchema.xml && innerSchema.xml.name || propertyName || config.propertyName;
+      const innerOverridePropertyName = prefix ? `${prefix}:${innerNodeName}` : innerNodeName;
+
+      if (innerSchema.xml && innerSchema.xml.attribute) {
+        xmlAttributes[innerOverridePropertyName] = propertyExamples[0];
+      } else {
+        xmlTagProperties.push({
+          [innerOverridePropertyName]: propertyExamples[0]
+        });
+      }
+    });
+
+    if (Object.keys(xmlAttributes).length) {
+      xmlTagProperties.push({
+        _attr: xmlAttributes
+      });
+    }
+
+    return config.xml ? [xmlTagProperties] : objectExamples;
+  }
+
+  const value = getSampleValueByType(schema, config.propertyName, config.skipExampleStrings);
+  return [value];
+}
+
+function removeTitlesAndDescriptions(obj) {
+  if (typeof obj !== 'object' || obj === null) {
+    return;
+  }
+
+  delete obj['::TITLE'];
+  delete obj['::DESCRIPTION'];
+
+  for (const k in obj) {
+    removeTitlesAndDescriptions(obj[k]);
+  }
+}
+/**
+ * For changing OpenAPI-Schema to an Object Notation,
+ * This Object would further be an input to UI Components to generate an Object-Tree
+ * @param {object} schema - Schema object from OpenAPI spec
+ * @param {object} obj - recursively pass this object to generate object notation
+ * @param {number} level - recursion level
+ * @param {string} suffix - used for suffixing property names to avoid duplicate props during object composition
+ */
+
+
+function schemaInObjectNotation(schema, obj, level = 0, suffix = '') {
+  if (!schema) {
+    return undefined;
+  }
+
+  if (schema.allOf) {
+    const objWithAllProps = {};
+
+    if (schema.allOf.length === 1 && !schema.allOf[0].properties && !schema.allOf[0].items) {
+      // If allOf has single item and the type is not an object or array, then its a primitive
+      const tempSchema = schema.allOf[0];
+      return `${getTypeInfo(tempSchema).html}`;
+    } // If allOf is an array of multiple elements, then all the keys makes a single object
+
+
+    schema.allOf.map((v, i) => {
+      if (v.type === 'object' || v.properties || v.allOf || v.anyOf || v.oneOf) {
+        const propSuffix = (v.anyOf || v.oneOf) && i > 0 ? i : '';
+        const partialObj = schemaInObjectNotation(v, {}, level + 1, propSuffix);
+        Object.assign(objWithAllProps, partialObj);
+      } else if (v.type === 'array' || v.items) {
+        const partialObj = schemaInObjectNotation(v, {}, level + 1);
+        Object.assign(objWithAllProps, partialObj);
+      } else if (v.type) {
+        const prop = `prop${Object.keys(objWithAllProps).length}`;
+        const typeObj = getTypeInfo(v);
+        objWithAllProps[prop] = `${typeObj.html}`;
+      }
+    }); // eslint-disable-next-line no-param-reassign
+
+    obj = objWithAllProps;
+  } else if (schema.anyOf || schema.oneOf) {
+    obj['::description'] = schema.description || ''; // 1. First iterate the regular properties
+
+    if (schema.type === 'object' || schema.properties) {
+      obj['::description'] = schema.description || '';
+      obj['::flags'] = {
+        '🆁': schema.readOnly && '🆁',
+        '🆆': schema.writeOnly && '🆆'
+      };
+      obj['::type'] = 'object'; // obj['::deprecated'] = schema.deprecated || false;
+
+      for (const key in schema.properties) {
+        if (schema.required && schema.required.includes(key)) {
+          obj[`${key}*`] = schemaInObjectNotation(schema.properties[key], {}, level + 1);
+        } else {
+          obj[key] = schemaInObjectNotation(schema.properties[key], {}, level + 1);
+        }
+      }
+    } // 2. Then show allof/anyof objects
+
+
+    const objWithAnyOfProps = {};
+    const xxxOf = schema.anyOf ? 'anyOf' : 'oneOf';
+    schema[xxxOf].forEach((v, index) => {
+      if (v.type === 'object' || v.properties || v.allOf || v.anyOf || v.oneOf) {
+        const partialObj = schemaInObjectNotation(v, {});
+        objWithAnyOfProps[`::OPTION~${index + 1}${v.title ? `~${v.title}` : ''}`] = partialObj;
+        objWithAnyOfProps['::type'] = 'xxx-of-option';
+      } else if (v.type === 'array' || v.items) {
+        // This else-if block never seems to get executed
+        const partialObj = schemaInObjectNotation(v, {});
+        objWithAnyOfProps[`::OPTION~${index + 1}${v.title ? `~${v.title}` : ''}`] = partialObj;
+        objWithAnyOfProps['::type'] = 'xxx-of-array';
+      } else {
+        const prop = `::OPTION~${index + 1}${v.title ? `~${v.title}` : ''}`;
+        objWithAnyOfProps[prop] = `${getTypeInfo(v).html}`;
+        objWithAnyOfProps['::type'] = 'xxx-of-option';
+      }
+    });
+    obj[schema.anyOf ? `::ANY~OF ${suffix}` : `::ONE~OF ${suffix}`] = objWithAnyOfProps;
+    obj['::type'] = 'xxx-of';
+  } else if (Array.isArray(schema.type)) {
+    // When a property has multiple types, then check further if any of the types are array or object, if yes then modify the schema using one-of
+    // Clone the schema - as it will be modified to replace multi-data-types with one-of;
+    const subSchema = JSON.parse(JSON.stringify(schema));
+    const primitiveType = [];
+    const complexTypes = [];
+    subSchema.type.forEach(v => {
+      if (v.match(/integer|number|string|null|boolean/g)) {
+        primitiveType.push(v);
+      } else if (v === 'array' && typeof (subSchema.items && subSchema.items.type) === 'string' && schema.items && subSchema.items.type.match(/integer|number|string|null|boolean/g)) {
+        // Array with primitive types should also be treated as primitive type
+        if (subSchema.items.type === 'string' && subSchema.items.format) {
+          primitiveType.push(`${subSchema.items.format}[]`);
+        } else {
+          primitiveType.push(`${subSchema.items.type}[]`);
+        }
+      } else {
+        complexTypes.push(v);
+      }
+    });
+    let multiPrimitiveTypes;
+
+    if (primitiveType.length > 0) {
+      subSchema.type = primitiveType.join('┃');
+      multiPrimitiveTypes = getTypeInfo(subSchema);
+
+      if (complexTypes.length === 0) {
+        return `${multiPrimitiveTypes && multiPrimitiveTypes.html || ''}`;
+      }
+    }
+
+    if (complexTypes.length > 0) {
+      obj['::type'] = 'xxx-of';
+      const multiTypeOptions = {
+        '::type': 'xxx-of-option'
+      }; // Generate ONE-OF options for complexTypes
+
+      complexTypes.forEach((v, i) => {
+        if (v === 'null') {
+          multiTypeOptions[`::OPTION~${i + 1}`] = 'NULL~|~~|~~|~~|~~|~~|~~|~~|~';
+        } else if ('integer, number, string, boolean,'.includes(`${v},`)) {
+          subSchema.type = Array.isArray(v) ? v.join('┃') : v;
+          const primitiveTypeInfo = getTypeInfo(subSchema);
+          multiTypeOptions[`::OPTION~${i + 1}`] = primitiveTypeInfo.html;
+        } else if (v === 'object') {
+          // If object type iterate all the properties and create an object-type-option
+          const objTypeOption = {
+            '::title': schema.title || '',
+            '::description': schema.description || '',
+            '::flags': {
+              '🆁': schema.readOnly && '🆁',
+              '🆆': schema.writeOnly && '🆆'
+            },
+            '::type': 'object',
+            '::deprecated': schema.deprecated || false
+          };
+
+          for (const key in schema.properties) {
+            if (schema.required && schema.required.includes(key)) {
+              objTypeOption[`${key}*`] = schemaInObjectNotation(schema.properties[key], {}, level + 1);
+            } else {
+              objTypeOption[key] = schemaInObjectNotation(schema.properties[key], {}, level + 1);
+            }
+          }
+
+          multiTypeOptions[`::OPTION~${i + 1}`] = objTypeOption;
+        } else if (v === 'array') {
+          multiTypeOptions[`::OPTION~${i + 1}`] = {
+            '::title': schema.title || '',
+            '::description': schema.description || '',
+            '::flags': {
+              '🆁': schema.readOnly && '🆁',
+              '🆆': schema.writeOnly && '🆆'
+            },
+            '::type': 'array',
+            '::props': schemaInObjectNotation(Object.assign({
+              readOnly: schema.readOnly,
+              writeOnly: schema.writeOnly
+            }, schema.items), {}, level + 1)
+          };
+        }
+      });
+      multiTypeOptions[`::OPTION~${complexTypes.length + 1}`] = multiPrimitiveTypes && multiPrimitiveTypes.html || '';
+      obj['::ONE~OF'] = multiTypeOptions;
+    }
+  } else if (schema.type === 'object' || schema.properties) {
+    obj['::title'] = schema.title || '';
+    obj['::description'] = schema.description || '';
+    obj['::flags'] = {
+      '🆁': schema.readOnly && '🆁',
+      '🆆': schema.writeOnly && '🆆'
+    };
+    obj['::type'] = 'object';
+    obj['::deprecated'] = schema.deprecated || false;
+
+    for (const key in schema.properties) {
+      if (schema.required && schema.required.includes(key)) {
+        obj[`${key}*`] = schemaInObjectNotation(schema.properties[key], {}, level + 1);
+      } else {
+        obj[key] = schemaInObjectNotation(schema.properties[key], {}, level + 1);
+      }
+    }
+
+    if (schema.additionalProperties) {
+      obj['<any-key>'] = schemaInObjectNotation(schema.additionalProperties, {});
+    }
+  } else if (schema.type === 'array' || schema.items) {
+    // If Array
+    obj['::title'] = schema.title || '';
+    obj['::description'] = schema.description ? schema.description : schema.items && schema.items.description ? `array&lt;${schema.items.description}&gt;` : '';
+    obj['::flags'] = {
+      '🆁': schema.readOnly && '🆁',
+      '🆆': schema.writeOnly && '🆆'
+    };
+    obj['::type'] = 'array';
+    obj['::deprecated'] = schema.deprecated || false;
+    obj['::props'] = schemaInObjectNotation(Object.assign({
+      deprecated: schema.deprecated,
+      readOnly: schema.readOnly,
+      writeOnly: schema.writeOnly
+    }, schema.items), {}, level + 1);
+  } else {
+    const typeObj = getTypeInfo(schema);
+
+    if (typeObj && typeObj.html) {
+      return `${typeObj.html}`;
+    }
+
+    return '';
+  }
+
+  return obj;
+}
+/* Create Example object */
+
+
+function generateExample(examples, example, schema, rawMimeType, includeReadOnly = true, includeWriteOnly = true, outputType, skipExampleStrings = false) {
+  const mimeType = rawMimeType || 'application/json';
+  const finalExamples = []; // First check if examples is provided
+
+  if (examples) {
+    for (const eg in examples) {
+      let egContent = '';
+      let egFormat = 'json';
+
+      if (mimeType.toLowerCase().includes('json')) {
+        if (outputType === 'text') {
+          egContent = typeof examples[eg].value === 'string' ? examples[eg].value : JSON.stringify(examples[eg].value, undefined, 2);
+          egFormat = 'text';
+        } else {
+          egContent = examples[eg].value;
+
+          if (typeof examples[eg].value === 'string') {
+            try {
+              const fixedJsonString = examples[eg].value.replace(/([\w]+)(:)/g, '"$1"$2').replace(/'/g, '"');
+              egContent = JSON.parse(fixedJsonString);
+              egFormat = 'json';
+            } catch (err) {
+              egFormat = 'text';
+              egContent = examples[eg].value;
+            }
+          }
+        }
+      } else {
+        egContent = examples[eg].value;
+        egFormat = 'text';
+      }
+
+      finalExamples.push({
+        exampleId: eg,
+        exampleSummary: examples[eg].summary || eg,
+        exampleDescription: examples[eg].description || '',
+        exampleType: mimeType,
+        exampleValue: egContent,
+        exampleFormat: egFormat
+      });
+    }
+  } else if (example) {
+    let egContent = '';
+    let egFormat = 'json';
+
+    if (mimeType.toLowerCase().includes('json')) {
+      if (outputType === 'text') {
+        egContent = typeof example === 'string' ? example : JSON.stringify(example, undefined, 2);
+        egFormat = 'text';
+      } else if (typeof example === 'object') {
+        egContent = example;
+        egFormat = 'json';
+      } else if (typeof example === 'string') {
+        try {
+          egContent = JSON.parse(example);
+          egFormat = 'json';
+        } catch (err) {
+          egFormat = 'text';
+          egContent = example;
+        }
+      }
+    } else {
+      egContent = example;
+      egFormat = 'text';
+    }
+
+    finalExamples.push({
+      exampleId: 'Example',
+      exampleSummary: '',
+      exampleDescription: '',
+      exampleType: mimeType,
+      exampleValue: egContent,
+      exampleFormat: egFormat
+    });
+  } // If schema-level examples are not provided then generate one based on the schema field types
+
+
+  if (finalExamples.length) {
+    return finalExamples;
+  }
+
+  if (schema && schema.example) {
+    // Note: schema.examples (plurals) is not allowed as per spec
+    return [{
+      exampleId: 'Example',
+      exampleSummary: '',
+      exampleDescription: '',
+      exampleType: mimeType,
+      exampleValue: schema.example,
+      exampleFormat: mimeType.toLowerCase().includes('json') && typeof schema.example === 'object' ? 'json' : 'text'
+    }];
+  }
+
+  const config = {
+    includeReadOnly,
+    includeWriteOnly,
+    skipExampleStrings,
+    xml: mimeType.toLowerCase().includes('xml')
+  };
+  const samples = getExampleValuesFromSchema(schema, config);
+
+  if (!samples || !mimeType.toLowerCase().includes('json') && !mimeType.toLowerCase().includes('text') && !mimeType.toLowerCase().includes('*/*') && !mimeType.toLowerCase().includes('xml')) {
+    return [{
+      exampleId: 'Example',
+      exampleSummary: '',
+      exampleDescription: '',
+      exampleType: mimeType,
+      exampleValue: '',
+      exampleFormat: 'text'
+    }];
+  }
+
+  return samples.map((sample, sampleCounter) => {
+    const summary = sample['::TITLE'] || `Example ${sampleCounter + 1}`;
+    const description = sample['::DESCRIPTION'] || '';
+    removeTitlesAndDescriptions(sample);
+    let exampleValue = '';
+
+    if (mimeType.toLowerCase().includes('xml')) {
+      exampleValue = (0, _xml.default)(sample, {
+        declaration: true,
+        indent: '    '
+      });
+    } else {
+      exampleValue = outputType === 'text' ? JSON.stringify(sample, null, 8) : sample;
+    }
+
+    return {
+      exampleId: `Example-${sampleCounter}`,
+      exampleSummary: summary,
+      exampleDescription: description,
+      exampleType: mimeType,
+      exampleFormat: mimeType.toLowerCase().includes('xml') ? 'text' : outputType,
+      exampleValue
+    };
+  }).filter(s => s);
+}