openapi-explorer 0.9.310 → 0.9.314

package/{src → dist/es}/utils/schema-utils.js

@@ -1,15 +1,15 @@
 import cloneDeep from 'lodash.clonedeep';
 import { expandN } from 'regex-to-strings';
-import xmlFormatter from './xml/xml';
+import xmlFormatter from './xml/xml'; // When the type is not known for a property set the displayed type to be this:
 
-// 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 */
+
 export function getTypeInfo(schema) {
   if (!schema) {
     return undefined;
   }
+
   let dataType = '';
   let constraint = '';
 
@@ -18,8 +18,9 @@ export function getTypeInfo(schema) {
     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;
+    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);
     }
@@ -30,48 +31,55 @@ export function getTypeInfo(schema) {
   const info = {
     type: dataType,
     format: schema.format || '',
-    pattern: (schema.pattern && !schema.enum) ? schema.pattern : '',
+    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}` : ''),
+    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: '',
+    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
+
 
-  // Set Allowed Values
   info.allowedValues = Array.isArray(schema.enum) ? schema.enum.join('┃') : '';
+
   if (dataType === 'array' && schema.items) {
-    const arrayItemType = schema.items.type;
-    const arrayItemDefault = schema.items.default ?? '';
+    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)) {
-    const minimum = schema.minimum ?? schema.exclusiveMinimum;
-    const maximum = schema.maximum ?? schema.exclusiveMaximum;
+    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 ?? ''},${maximum ?? ''}${rightBound}`;
+      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}`;
@@ -81,6 +89,7 @@ export function getTypeInfo(schema) {
       constraint += `Max length: ${schema.maxLength}`;
     }
   }
+
   info.constraint = constraint;
   info.html = JSON.stringify({
     type: info.type,
@@ -95,95 +104,131 @@ export function getTypeInfo(schema) {
   });
   return info;
 }
-
 export 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 (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 ?? '';
+
+  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;
+    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(/^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.enum) {
+      return schemaObj.enum[0];
+    }
+
     if (schemaObj.pattern) {
       const examplePattern = schemaObj.pattern.replace(/[+*](?![^\][]*[\]])/g, '{8}').replace(/\{\d*,(\d+)?\}/g, '{8}');
       return 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];
+          return new Date().toISOString().split('T')[0];
+
         case 'time':
-          return (new Date()).toISOString().split('T')[1];
+          return new Date().toISOString().split('T')[1];
+
         case 'date-time':
-          return (new Date()).toISOString();
+          return new Date().toISOString();
+
         case 'duration':
-          return 'P3Y6M4DT12H30M5S'; // P=Period 3-Years 6-Months 4-Days 12-Hours 30-Minutes 5-Seconds
+          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
+  } // 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) => ({
-      ...cloneDeep(example),
-      [propertyName]: value,
+    const examplesFromPropertyValues = propertyValues.slice(0, 2).map(value => ({ ...cloneDeep(example),
+      [propertyName]: value
     }));
     return exampleList.concat(...examplesFromPropertyValues);
   }, []).slice(0, 10);
@@ -192,25 +237,34 @@ function duplicateExampleWithNewPropertyValues(objectExamples, propertyName, pro
 export 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]);
+    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
 
-// 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
+
 
-  // XML Support
   const xmlAttributes = {};
   const xmlTagProperties = [];
-  const { prefix, namespace } = schema.xml || {};
+  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;
 
@@ -220,55 +274,83 @@ function getExampleValuesFromSchemaRecursive(schema, config = {}) {
   }
 
   if (schema.oneOf) {
-    return schema.oneOf.map((s) => getExampleValuesFromSchemaRecursive(s, config)).flat(1);
+    return schema.oneOf.map(s => getExampleValuesFromSchemaRecursive(s, config)).flat(1);
   }
 
   if (schema.anyOf) {
-    return schema.anyOf.map((s) => getExampleValuesFromSchemaRecursive(s, config)).flat(1);
+    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 });
+      xmlTagProperties.push({
+        [overridePropertyName]: arrayExamples[0]
+      }, {
+        _attr: xmlAttributes
+      });
       return [xmlTagProperties];
     }
 
-    const arrayExamples = getExampleValuesFromSchemaRecursive(schema.items || {}, { ...config, propertyName: overridePropertyName });
-    xmlTagProperties.push({ [overridePropertyName]: arrayExamples[0] }, { _attr: xmlAttributes });
+    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) => {
+    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 });
+      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] });
+        xmlTagProperties.push({
+          [innerOverridePropertyName]: propertyExamples[0]
+        });
       }
     });
+
     if (Object.keys(xmlAttributes).length) {
-      xmlTagProperties.push({ _attr: xmlAttributes });
+      xmlTagProperties.push({
+        _attr: xmlAttributes
+      });
     }
+
     return config.xml ? [xmlTagProperties] : objectExamples;
   }
 
@@ -280,13 +362,14 @@ 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
@@ -295,51 +378,60 @@ function removeTitlesAndDescriptions(obj) {
  * @param {number} level - recursion level
  * @param {string} suffix - used for suffixing property names to avoid duplicate props during object composition
  */
+
+
 export 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
+    } // 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);
+        const partialObj = schemaInObjectNotation(v, {}, level + 1, propSuffix);
         Object.assign(objWithAllProps, partialObj);
       } else if (v.type === 'array' || v.items) {
-        const partialObj = schemaInObjectNotation(v, {}, (level + 1));
+        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
+    }); // 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
+    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;
+      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));
+          obj[`${key}*`] = schemaInObjectNotation(schema.properties[key], {}, level + 1);
         } else {
-          obj[key] = schemaInObjectNotation(schema.properties[key], {}, (level + 1));
+          obj[key] = schemaInObjectNotation(schema.properties[key], {}, level + 1);
         }
       }
-    }
-    // 2. Then show allof/anyof objects
+    } // 2. Then show allof/anyof objects
+
+
     const objWithAnyOfProps = {};
     const xxxOf = schema.anyOf ? 'anyOf' : 'oneOf';
     schema[xxxOf].forEach((v, index) => {
@@ -358,7 +450,7 @@ export function schemaInObjectNotation(schema, obj, level = 0, suffix = '') {
         objWithAnyOfProps['::type'] = 'xxx-of-option';
       }
     });
-    obj[(schema.anyOf ? `::ANY~OF ${suffix}` : `::ONE~OF ${suffix}`)] = objWithAnyOfProps;
+    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
@@ -366,7 +458,7 @@ export function schemaInObjectNotation(schema, obj, level = 0, suffix = '') {
     const subSchema = JSON.parse(JSON.stringify(schema));
     const primitiveType = [];
     const complexTypes = [];
-    subSchema.type.forEach((v) => {
+    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)) {
@@ -381,20 +473,22 @@ export function schemaInObjectNotation(schema, obj, level = 0, suffix = '') {
       }
     });
     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',
-      };
+        '::type': 'xxx-of-option'
+      }; // Generate ONE-OF options for complexTypes
 
-      // Generate ONE-OF options for complexTypes
       complexTypes.forEach((v, i) => {
         if (v === 'null') {
           multiTypeOptions[`::OPTION~${i + 1}`] = 'NULL~|~~|~~|~~|~~|~~|~~|~~|~';
@@ -407,25 +501,36 @@ export function schemaInObjectNotation(schema, obj, level = 0, suffix = '') {
           const objTypeOption = {
             '::title': schema.title || '',
             '::description': schema.description || '',
-            '::flags': { '🆁': schema.readOnly && '🆁', '🆆': schema.writeOnly && '🆆' },
+            '::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));
+              objTypeOption[`${key}*`] = schemaInObjectNotation(schema.properties[key], {}, level + 1);
             } else {
-              objTypeOption[key] = schemaInObjectNotation(schema.properties[key], {}, (level + 1));
+              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 && '🆆' },
+            '::flags': {
+              '🆁': schema.readOnly && '🆁',
+              '🆆': schema.writeOnly && '🆆'
+            },
             '::type': 'array',
-            '::props': schemaInObjectNotation(Object.assign({ readOnly: schema.readOnly, writeOnly: schema.writeOnly }, schema.items), {}, (level + 1)),
+            '::props': schemaInObjectNotation(Object.assign({
+              readOnly: schema.readOnly,
+              writeOnly: schema.writeOnly
+            }, schema.items), {}, level + 1)
           };
         }
       });
@@ -435,58 +540,72 @@ export function schemaInObjectNotation(schema, obj, level = 0, suffix = '') {
   } else if (schema.type === 'object' || schema.properties) {
     obj['::title'] = schema.title || '';
     obj['::description'] = schema.description || '';
-    obj['::flags'] = { '🆁': schema.readOnly && '🆁', '🆆': schema.writeOnly && '🆆' };
+    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));
+        obj[`${key}*`] = schemaInObjectNotation(schema.properties[key], {}, level + 1);
       } else {
-        obj[key] = schemaInObjectNotation(schema.properties[key], {}, (level + 1));
+        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
+  } 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['::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));
+    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 */
+
 export 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
+  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), '"');
+              const fixedJsonString = examples[eg].value.replace(/([\w]+)(:)/g, '"$1"$2').replace(/'/g, '"');
               egContent = JSON.parse(fixedJsonString);
               egFormat = 'json';
             } catch (err) {
@@ -506,12 +625,13 @@ export function generateExample(examples, example, schema, rawMimeType, includeR
         exampleDescription: examples[eg].description || '',
         exampleType: mimeType,
         exampleValue: egContent,
-        exampleFormat: egFormat,
+        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);
@@ -532,29 +652,31 @@ export function generateExample(examples, example, schema, rawMimeType, includeR
       egContent = example;
       egFormat = 'text';
     }
+
     finalExamples.push({
       exampleId: 'Example',
       exampleSummary: '',
       exampleDescription: '',
       exampleType: mimeType,
       exampleValue: egContent,
-      exampleFormat: egFormat,
+      exampleFormat: egFormat
     });
-  }
+  } // If schema-level examples are not provided then generate one based on the schema field types
+
 
-  // 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
+  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'),
+      exampleFormat: mimeType.toLowerCase().includes('json') && typeof schema.example === 'object' ? 'json' : 'text'
     }];
   }
 
@@ -562,19 +684,18 @@ export function generateExample(examples, example, schema, rawMimeType, includeR
     includeReadOnly,
     includeWriteOnly,
     skipExampleStrings,
-    xml: mimeType.toLowerCase().includes('xml'),
+    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'))) {
+  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',
+      exampleFormat: 'text'
     }];
   }
 
@@ -582,10 +703,13 @@ export function generateExample(examples, example, schema, rawMimeType, includeR
     const summary = sample['::TITLE'] || `Example ${sampleCounter + 1}`;
     const description = sample['::DESCRIPTION'] || '';
     removeTitlesAndDescriptions(sample);
-
     let exampleValue = '';
+
     if (mimeType.toLowerCase().includes('xml')) {
-      exampleValue = xmlFormatter(sample, { declaration: true, indent: '    ' });
+      exampleValue = xmlFormatter(sample, {
+        declaration: true,
+        indent: '    '
+      });
     } else {
       exampleValue = outputType === 'text' ? JSON.stringify(sample, null, 8) : sample;
     }
@@ -596,7 +720,7 @@ export function generateExample(examples, example, schema, rawMimeType, includeR
       exampleDescription: description,
       exampleType: mimeType,
       exampleFormat: mimeType.toLowerCase().includes('xml') ? 'text' : outputType,
-      exampleValue,
+      exampleValue
     };
-  }).filter((s) => s);
-}
+  }).filter(s => s);
+}