openapi-explorer 0.8.282 → 0.8.285

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openapi-explorer",
-  "version": "0.8.282",
+  "version": "0.8.285",
   "description": "OpenAPI Explorer - API viewer with dynamically generated components, documentation, and interaction console",
   "author": "Rhosys Developers <developers@rhosys.ch>",
   "repository": {
@@ -39,11 +39,10 @@
   ],
   "mode": "production",
   "dependencies": {
-    "@kyleshockey/xml": "^1.0.2",
     "authress-login": "^1.1.77",
     "base64url": "^3.0.1",
     "buffer": "^6.0.3",
-    "color": "^3.1.3",
+    "color": "^4.2.3",
     "create-hash": "^1.2.0",
     "js-yaml": "^4.0",
     "lit-element": "2.4.0",

package/src/openapi-explorer-oauth-handler.js

@@ -5,4 +5,7 @@ export default class OpenapiExplorerOauthHandler extends HTMLElement {
     checkForAuthToken(true);
   }
 }
-customElements.define('openapi-explorer-oauth-handler', OpenapiExplorerOauthHandler);
+
+if (!customElements.get('openapi-explorer-oauth-handler')) {
+  customElements.define('openapi-explorer-oauth-handler', OpenapiExplorerOauthHandler);
+}

package/src/openapi-explorer.js

@@ -31,6 +31,11 @@ import responsiveViewMainBodyTemplate from './templates/responsiveViewMainBodyTe
 import apiRequestStyles from './styles/api-request-styles';
 import { checkForAuthToken } from './templates/security-scheme-template';
 
+if (typeof global === undefined) {
+  // eslint-disable-next-line no-global-assign
+  global = {};
+}
+
 export default class OpenApiExplorer extends LitElement {
   constructor() {
     super();
@@ -795,5 +800,7 @@ export default class OpenApiExplorer extends LitElement {
   }
 }
 
-customElements.define('openapi-explorer', OpenApiExplorer);
+if (!customElements.get('openapi-explorer')) {
+  customElements.define('openapi-explorer', OpenApiExplorer);
+}
 import './openapi-explorer-oauth-handler';

package/src/utils/schema-utils.js

@@ -1,7 +1,6 @@
 import cloneDeep from 'lodash.clonedeep';
 import { expandN } from 'regex-to-strings';
-
-const xmlFormatter = require('@kyleshockey/xml');
+import xmlFormatter from './xml/xml';
 
 /* Generates an schema object containing type and constraint info */
 export function getTypeInfo(schema) {

package/src/utils/xml/xml.js

@@ -0,0 +1,258 @@
+/* eslint-disable no-underscore-dangle */
+
+const XML_CHARACTER_MAP = {
+  '&': '&',
+  '"': '"',
+  "'": ''',
+  '<': '&lt;',
+  '>': '&gt;'
+};
+
+function escapeForXML(string) {
+  return string && string.replace
+    ? string.replace(/([&"<>'])/g, function(str, item) {
+      return XML_CHARACTER_MAP[item];
+    })
+    : string;
+}
+
+const DEFAULT_INDENT = '    ';
+
+function xml(input, rawOptions) {
+  let options = rawOptions;
+  if (typeof options !== 'object') {
+    options = {
+      indent: options
+    };
+  }
+
+  let output = '';
+  const indent = !options.indent ? ''
+    : options.indent === true ? DEFAULT_INDENT
+      : options.indent;
+  let instant = true;
+
+  function delay(func) {
+    if (!instant) {
+      func();
+    } else {
+      process.nextTick(func);
+    }
+  }
+
+  function append(_, out) {
+    if (out !== undefined) {
+      output += out;
+    }
+  }
+
+  function add(value, last) {
+    format(append, resolve(value, indent, indent ? 1 : 0), last);
+  }
+
+  function addXmlDeclaration(declaration) {
+    const encoding = declaration.encoding || 'UTF-8';
+    const attr = { version: '1.0', encoding: encoding };
+
+    if (declaration.standalone) {
+      attr.standalone = declaration.standalone;
+    }
+
+    add({ '?xml': { _attr: attr } });
+    output = output.replace('/>', '?>');
+  }
+
+  // disable delay delayed
+  delay(function() { instant = false; });
+
+  if (options.declaration) {
+    addXmlDeclaration(options.declaration);
+  }
+
+  if (input && input.forEach) {
+    input.forEach(function(value, i) {
+      add(value, i + 1 === input.length);
+    });
+  } else {
+    add(input, true);
+  }
+
+  return output;
+}
+
+function element(/* input, …*/) {
+  const input = Array.prototype.slice.call(arguments);
+  const self = {
+    _elem: resolve(input)
+  };
+
+  self.push = function(pushInput) {
+    if (!this.append) {
+      throw new Error('not assigned to a parent!');
+    }
+    const that = this;
+    const indent = this._elem.indent;
+    format(this.append, resolve(
+      pushInput, indent, this._elem.icount + (indent ? 1 : 0)),
+    function() { that.append(true); });
+  };
+
+  self.close = function(closeInput) {
+    if (closeInput !== undefined) {
+      this.push(closeInput);
+    }
+  };
+
+  return self;
+}
+
+function create_indent(character, count) {
+  return (new Array(count || 0).join(character || ''));
+}
+
+function resolve(data, indent, indent_count_raw) {
+  const indent_count = indent_count_raw || 0;
+  const indent_spaces = create_indent(indent, indent_count);
+  let name;
+  let values = data;
+  const interrupt = false;
+
+  if (typeof data === 'object') {
+    const keys = Object.keys(data);
+    name = keys[0];
+    values = data[name];
+
+    if (values && values._elem) {
+      values._elem.name = name;
+      values._elem.icount = indent_count;
+      values._elem.indent = indent;
+      values._elem.indents = indent_spaces;
+      values._elem.interrupt = values;
+      return values._elem;
+    }
+  }
+
+  const attributes = [];
+  const content = [];
+
+  let isStringContent;
+
+  function get_attributes(obj) {
+    const keys = Object.keys(obj);
+    keys.forEach(function(key) {
+      attributes.push(attribute(key, obj[key]));
+    });
+  }
+
+  switch (typeof values) {
+    case 'object':
+      if (values === null) {break;}
+
+      if (values._attr) {
+        get_attributes(values._attr);
+      }
+
+      if (values._cdata) {
+        content.push(
+          `${(`<![CDATA[${values._cdata}`).replace(/\]\]>/g, ']]]]><![CDATA[>')}]]>`
+        );
+      }
+
+      if (values.forEach) {
+        isStringContent = false;
+        content.push('');
+        values.forEach(function(value) {
+          if (typeof value === 'object') {
+            const _name = Object.keys(value)[0];
+
+            if (_name === '_attr') {
+              get_attributes(value._attr);
+            } else {
+              content.push(resolve(
+                value, indent, indent_count + 1));
+            }
+          } else {
+            // string
+            content.pop();
+            isStringContent = true;
+            content.push(escapeForXML(value));
+          }
+        });
+        if (!isStringContent) {
+          content.push('');
+        }
+      }
+      break;
+
+    default:
+      // string
+      content.push(escapeForXML(values));
+  }
+
+  return {
+    name: name,
+    interrupt: interrupt,
+    attributes: attributes,
+    content: content,
+    icount: indent_count,
+    indents: indent_spaces,
+    indent: indent
+  };
+}
+
+function format(append, elem, end) {
+  if (typeof elem !== 'object') {
+    append(false, elem);
+    return;
+  }
+
+  const len = elem.interrupt ? 1 : elem.content.length;
+
+  function proceed() {
+    while (elem.content.length) {
+      const value = elem.content.shift();
+
+      if (value === undefined) {continue;}
+      if (interrupt(value)) {return;}
+
+      format(append, value);
+    }
+
+    append(false, (len > 1 ? elem.indents : '')
+            + (elem.name ? `</${elem.name}>` : '')
+            + (elem.indent && !end ? '\n' : ''));
+  }
+
+  function interrupt(value) {
+    if (value.interrupt) {
+      value.interrupt.append = append;
+      value.interrupt.end = proceed;
+      value.interrupt = false;
+      append(true);
+      return true;
+    }
+    return false;
+  }
+
+  append(false, elem.indents
+        + (elem.name ? `<${elem.name}` : '')
+        + (elem.attributes.length ? ` ${elem.attributes.join(' ')}` : '')
+        + (len ? (elem.name ? '>' : '') : (elem.name ? '/>' : ''))
+        + (elem.indent && len > 1 ? '\n' : ''));
+
+  if (!len) {
+    append(false, elem.indent ? '\n' : '');
+    return;
+  }
+
+  if (!interrupt(elem)) {
+    proceed();
+  }
+}
+
+function attribute(key, value) {
+  return `${key}=` + `"${escapeForXML(value)}"`;
+}
+
+module.exports = xml;
+module.exports.element = module.exports.Element = element;