@swagger-api/apidom-core 0.68.1

package/es/predicates/helpers.js

@@ -0,0 +1,22 @@
+const hasMethod = (name, obj) => typeof (obj === null || obj === void 0 ? void 0 : obj[name]) === 'function';
+const hasBasicElementProps = element => element != null && Object.prototype.hasOwnProperty.call(element, '_storedElement') && Object.prototype.hasOwnProperty.call(element, '_content');
+const primitiveEq = (val, obj) => {
+  var _obj$primitive;
+  return (obj === null || obj === void 0 ? void 0 : (_obj$primitive = obj.primitive) === null || _obj$primitive === void 0 ? void 0 : _obj$primitive.call(obj)) === val;
+};
+const hasClass = (cls, obj) => {
+  var _obj$classes, _obj$classes$includes;
+  return (obj === null || obj === void 0 ? void 0 : (_obj$classes = obj.classes) === null || _obj$classes === void 0 ? void 0 : (_obj$classes$includes = _obj$classes.includes) === null || _obj$classes$includes === void 0 ? void 0 : _obj$classes$includes.call(_obj$classes, cls)) || false;
+};
+export const isElementType = (name, element) => (element === null || element === void 0 ? void 0 : element.element) === name;
+const createPredicate = predicateCreator => {
+  // @ts-ignore
+  return predicateCreator({
+    hasMethod,
+    hasBasicElementProps,
+    primitiveEq,
+    isElementType,
+    hasClass
+  });
+};
+export default createPredicate;

package/es/predicates/index.js

@@ -0,0 +1,124 @@
+import { Element, StringElement, NumberElement, NullElement, BooleanElement, ArrayElement, ObjectElement, MemberElement, LinkElement, RefElement } from 'minim';
+import { all } from 'ramda';
+import { included } from 'ramda-adjunct';
+import AnnotationElement from "../elements/Annotation.js";
+import CommentElement from "../elements/Comment.js";
+import ParserResultElement from "../elements/ParseResult.js";
+import SourceMapElement from "../elements/SourceMap.js";
+import createPredicate, { isElementType as isElementTypeHelper } from "./helpers.js";
+export const isElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof Element || hasBasicElementProps(element) && primitiveEq(undefined, element);
+});
+export const isStringElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof StringElement || hasBasicElementProps(element) && primitiveEq('string', element);
+});
+export const isNumberElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof NumberElement || hasBasicElementProps(element) && primitiveEq('number', element);
+});
+export const isNullElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof NullElement || hasBasicElementProps(element) && primitiveEq('null', element);
+});
+export const isBooleanElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof BooleanElement || hasBasicElementProps(element) && primitiveEq('boolean', element);
+});
+export const isObjectElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq,
+  hasMethod
+}) => {
+  return element => element instanceof ObjectElement || hasBasicElementProps(element) && primitiveEq('object', element) && hasMethod('keys', element) && hasMethod('values', element) && hasMethod('items', element);
+});
+export const isArrayElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq,
+  hasMethod
+}) => {
+  return element => element instanceof ArrayElement && !(element instanceof ObjectElement) || hasBasicElementProps(element) && primitiveEq('array', element) && hasMethod('push', element) && hasMethod('unshift', element) && hasMethod('map', element) && hasMethod('reduce', element);
+});
+export const isMemberElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof MemberElement || hasBasicElementProps(element) && isElementType('member', element) && primitiveEq(undefined, element);
+});
+export const isLinkElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof LinkElement || hasBasicElementProps(element) && isElementType('link', element) && primitiveEq(undefined, element);
+});
+export const isRefElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof RefElement || hasBasicElementProps(element) && isElementType('ref', element) && primitiveEq(undefined, element);
+});
+export const isAnnotationElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof AnnotationElement || hasBasicElementProps(element) && isElementType('annotation', element) && primitiveEq('array', element);
+});
+export const isCommentElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof CommentElement || hasBasicElementProps(element) && isElementType('comment', element) && primitiveEq('string', element);
+});
+export const isParseResultElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ParserResultElement || hasBasicElementProps(element) && isElementType('parseResult', element) && primitiveEq('array', element);
+});
+export const isSourceMapElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof SourceMapElement || hasBasicElementProps(element) && isElementType('sourceMap', element) && primitiveEq('array', element);
+});
+export const isPrimitiveElement = element => {
+  return isElementTypeHelper('object', element) || isElementTypeHelper('array', element) || isElementTypeHelper('boolean', element) || isElementTypeHelper('number', element) || isElementTypeHelper('string', element) || isElementTypeHelper('null', element) || isElementTypeHelper('member', element);
+};
+export const hasElementSourceMap = element => {
+  var _element$meta, _element$meta$get;
+  return isSourceMapElement(element === null || element === void 0 ? void 0 : (_element$meta = element.meta) === null || _element$meta === void 0 ? void 0 : (_element$meta$get = _element$meta.get) === null || _element$meta$get === void 0 ? void 0 : _element$meta$get.call(_element$meta, 'sourceMap'));
+};
+export const includesSymbols = (symbols, element) => {
+  if (symbols.length === 0) {
+    return true;
+  }
+  const elementSymbols = element.attributes.get('symbols');
+  if (!isArrayElement(elementSymbols)) {
+    return false;
+  }
+  return all(included(elementSymbols.toValue()), symbols);
+};
+export const includesClasses = (classes, element) => {
+  if (classes.length === 0) {
+    return true;
+  }
+  return all(included(element.classes.toValue()), classes);
+};

package/es/refractor/index.js

@@ -0,0 +1,32 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { dispatchPlugins } from "./plugins/utils/index.js";
+import { getNodeType } from "../traversal/visitor.js";
+import createToolbox from "./toolbox.js";
+const refract = (value, {
+  Type,
+  plugins = []
+}) => {
+  /**
+   * This is where values gets refracted into generic ApiDOM.
+   * We don't allow consumers to hook into this translation.
+   * Though we allow consumers to define their onw plugins on already transformed ApiDOM.
+   */
+  const element = new Type(value);
+
+  /**
+   * Run plugins only when necessary.
+   * Running plugins visitors means extra single traversal === performance hit.
+   */
+  return dispatchPlugins(element, plugins, {
+    toolboxCreator: createToolbox,
+    visitorOptions: {
+      nodeTypeGetter: getNodeType
+    }
+  });
+};
+export const createRefractor = Type => (value, options = {}) => refract(value, _objectSpread(_objectSpread({}, options), {}, {
+  Type
+}));
+export default refract;

package/es/refractor/plugins/element-identity.js

@@ -0,0 +1,30 @@
+// @ts-ignore
+import ShortUniqueId from 'short-unique-id';
+import { StringElement } from 'minim';
+
+/**
+ * Plugin for decorating every element in ApiDOM tree with UUID.
+ */
+
+const plugin = ({
+  length = 6
+} = {}) => () => {
+  let uuid;
+  return {
+    pre() {
+      uuid = new ShortUniqueId({
+        length
+      });
+    },
+    visitor: {
+      enter(element) {
+        // eslint-disable-next-line no-param-reassign
+        element.id = new StringElement(uuid());
+      }
+    },
+    post() {
+      uuid = null;
+    }
+  };
+};
+export default plugin;

package/es/refractor/plugins/semantic-element-identity.js

@@ -0,0 +1,34 @@
+// @ts-ignore
+import ShortUniqueId from 'short-unique-id';
+import { StringElement } from 'minim';
+
+/**
+ * Plugin for decorating every semantic element in ApiDOM tree with UUID.
+ */
+
+const plugin = ({
+  length = 6
+} = {}) => ({
+  predicates
+}) => {
+  let uuid;
+  return {
+    pre() {
+      uuid = new ShortUniqueId({
+        length
+      });
+    },
+    visitor: {
+      enter(element) {
+        if (!predicates.isPrimitiveElement(element)) {
+          // eslint-disable-next-line no-param-reassign
+          element.id = new StringElement(uuid());
+        }
+      }
+    },
+    post() {
+      uuid = null;
+    }
+  };
+};
+export default plugin;

package/es/refractor/plugins/utils/index.js

@@ -0,0 +1,19 @@
+import { propOr } from 'ramda';
+import { invokeArgs } from 'ramda-adjunct';
+import createToolbox from "../../toolbox.js";
+import { getNodeType, mergeAllVisitors, visit } from "../../../traversal/visitor.js"; // eslint-disable-next-line import/prefer-default-export
+export const dispatchPlugins = (element, plugins, options = {}) => {
+  if (plugins.length === 0) return element;
+  const toolboxCreator = propOr(createToolbox, 'toolboxCreator', options);
+  const visitorOptions = propOr({}, 'visitorOptions', options);
+  const nodeTypeGetter = propOr(getNodeType, 'nodeTypeGetter', visitorOptions);
+  const toolbox = toolboxCreator();
+  const pluginsSpecs = plugins.map(plugin => plugin(toolbox));
+  const pluginsVisitor = mergeAllVisitors(pluginsSpecs.map(propOr({}, 'visitor')), {
+    nodeTypeGetter
+  });
+  pluginsSpecs.forEach(invokeArgs(['pre'], []));
+  const newElement = visit(element, pluginsVisitor, visitorOptions);
+  pluginsSpecs.forEach(invokeArgs(['post'], []));
+  return newElement;
+};

package/es/refractor/registration.js

@@ -0,0 +1,19 @@
+import { ObjectElement, ArrayElement, StringElement, BooleanElement, NullElement, NumberElement, LinkElement, RefElement } from 'minim';
+import AnnotationElement from "../elements/Annotation.js";
+import CommentElement from "../elements/Comment.js";
+import ParseResultElement from "../elements/ParseResult.js";
+import SourceMapElement from "../elements/SourceMap.js";
+import { createRefractor } from "./index.js";
+ObjectElement.refract = createRefractor(ObjectElement);
+ArrayElement.refract = createRefractor(ArrayElement);
+StringElement.refract = createRefractor(StringElement);
+BooleanElement.refract = createRefractor(BooleanElement);
+NullElement.refract = createRefractor(NullElement);
+NumberElement.refract = createRefractor(NumberElement);
+LinkElement.refract = createRefractor(LinkElement);
+RefElement.refract = createRefractor(RefElement);
+AnnotationElement.refract = createRefractor(AnnotationElement);
+CommentElement.refract = createRefractor(CommentElement);
+ParseResultElement.refract = createRefractor(ParseResultElement);
+SourceMapElement.refract = createRefractor(SourceMapElement);
+export { ObjectElement, ArrayElement, StringElement, BooleanElement, NullElement, NumberElement, LinkElement, RefElement, AnnotationElement, CommentElement, ParseResultElement, SourceMapElement };

package/es/refractor/toolbox.js

@@ -0,0 +1,13 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import * as basePredicates from "../predicates/index.js";
+import defaultNamespaceInstance from "../namespace.js";
+const createToolbox = () => {
+  const predicates = _objectSpread({}, basePredicates);
+  return {
+    predicates,
+    namespace: defaultNamespaceInstance
+  };
+};
+export default createToolbox;

package/es/serializers/json.js

@@ -0,0 +1,3 @@
+import serializeValue from "./value/index.js";
+const serializer = element => JSON.stringify(serializeValue(element));
+export default serializer;

package/es/serializers/value/ast/ephemeral-array.js

@@ -0,0 +1,18 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+class EphemeralArray {
+  constructor(content) {
+    _defineProperty(this, "type", 'EphemeralArray');
+    _defineProperty(this, "content", []);
+    _defineProperty(this, "reference", undefined);
+    this.content = content;
+    this.reference = [];
+  }
+  toReference() {
+    return this.reference;
+  }
+  toArray() {
+    this.reference.push(...this.content);
+    return this.reference;
+  }
+}
+export default EphemeralArray;

package/es/serializers/value/ast/ephemeral-object.js

@@ -0,0 +1,17 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+class EphemeralObject {
+  constructor(content) {
+    _defineProperty(this, "type", 'EphemeralObject');
+    _defineProperty(this, "content", []);
+    _defineProperty(this, "reference", undefined);
+    this.content = content;
+    this.reference = {};
+  }
+  toReference() {
+    return this.reference;
+  }
+  toObject() {
+    return Object.assign(this.reference, Object.fromEntries(this.content));
+  }
+}
+export default EphemeralObject;

package/es/serializers/value/index.js

@@ -0,0 +1,61 @@
+import stampit from 'stampit';
+import { visit } from "./visitor.js";
+import EphemeralArray from "./ast/ephemeral-array.js";
+import EphemeralObject from "./ast/ephemeral-object.js";
+/* eslint-disable @typescript-eslint/naming-convention */
+const Visitor = stampit.init(function _Visitor() {
+  const references = new WeakMap();
+  this.BooleanElement = function _BooleanElement(element) {
+    return element.toValue();
+  };
+  this.NumberElement = function _NumberElement(element) {
+    return element.toValue();
+  };
+  this.StringElement = function _StringElement(element) {
+    return element.toValue();
+  };
+  this.NullElement = function _NullElement() {
+    return null;
+  };
+  this.ObjectElement = {
+    enter(element) {
+      if (references.has(element)) {
+        return references.get(element).toReference();
+      }
+      const ephemeral = new EphemeralObject(element.content);
+      references.set(element, ephemeral);
+      return ephemeral;
+    }
+  };
+  this.EphemeralObject = {
+    leave(ephemeral) {
+      return ephemeral.toObject();
+    }
+  };
+  this.MemberElement = {
+    enter(element) {
+      return [element.key, element.value];
+    }
+  };
+  this.ArrayElement = {
+    enter(element) {
+      if (references.has(element)) {
+        return references.get(element).toReference();
+      }
+      const ephemeral = new EphemeralArray(element.content);
+      references.set(element, ephemeral);
+      return ephemeral;
+    }
+  };
+  this.EphemeralArray = {
+    leave(ephemeral) {
+      return ephemeral.toArray();
+    }
+  };
+});
+/* eslint-enable */
+
+const serializer = element => {
+  return visit(element, Visitor());
+};
+export default serializer;

package/es/serializers/value/visitor.js

@@ -0,0 +1,54 @@
+import _objectWithoutProperties from "@babel/runtime-corejs3/helpers/esm/objectWithoutProperties";
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+const _excluded = ["keyMap"],
+  _excluded2 = ["keyMap"];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import { T as stubTrue } from 'ramda';
+import { visit as astVisit, keyMapDefault as baseKeyMap, getNodeType as baseGetNodeType } from "../../traversal/visitor.js";
+const nodeTypeGetter = node => {
+  if (typeof (node === null || node === void 0 ? void 0 : node.type) === 'string') {
+    return node.type;
+  }
+  return baseGetNodeType(node);
+};
+const keyMapDefault = _objectSpread({
+  EphemeralObject: ['content'],
+  EphemeralArray: ['content']
+}, baseKeyMap);
+
+// eslint-disable-next-line import/prefer-default-export
+export const visit = (root,
+// @ts-ignore
+visitor, _ref = {}) => {
+  let {
+      keyMap = keyMapDefault
+    } = _ref,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  return astVisit(root, visitor, _objectSpread({
+    keyMap,
+    // @ts-ignore
+    nodeTypeGetter,
+    nodePredicate: stubTrue,
+    detectCycles: false,
+    deleteNodeSymbol: Symbol.for('delete-node'),
+    skipVisitingNodeSymbol: Symbol.for('skip-visiting-node')
+  }, rest));
+};
+
+// @ts-ignore
+visit[Symbol.for('nodejs.util.promisify.custom')] = async (root, _ref2 = {}) => {
+  let {
+      keyMap = keyMapDefault
+    } = _ref2,
+    rest = _objectWithoutProperties(_ref2, _excluded2);
+  // @ts-ignore
+  return astVisit[Symbol.for('nodejs.util.promisify.custom')](root, visitor, _objectSpread({
+    keyMap,
+    nodeTypeGetter,
+    nodePredicate: stubTrue,
+    detectCycles: false,
+    deleteNodeSymbol: Symbol.for('delete-node'),
+    skipVisitingNodeSymbol: Symbol.for('skip-visiting-node')
+  }, rest));
+};

package/es/serializers/yaml-1-2.js

@@ -0,0 +1,87 @@
+import stampit from 'stampit';
+import { visit } from "../traversal/visitor.js";
+import serializeValue from "./value/index.js";
+const YamlVisitor = stampit({
+  props: {
+    result: '',
+    indent: 0,
+    indentChar: '  '
+  },
+  init({
+    signature = '',
+    indent = 0,
+    indentChar = '  '
+  } = {}) {
+    this.result = signature;
+    this.indent = indent;
+    this.indentChard = indentChar;
+  },
+  methods: {
+    NumberElement(element) {
+      this.result += serializeValue(element);
+    },
+    BooleanElement(element) {
+      const value = serializeValue(element);
+      this.result += value ? 'true' : 'false';
+    },
+    StringElement(element) {
+      // for simplicity and avoiding ambiguity we always wrap strings in quotes
+      this.result += JSON.stringify(serializeValue(element));
+    },
+    NullElement() {
+      this.result += 'null';
+    },
+    ArrayElement(element) {
+      if (element.length === 0) {
+        this.result += '[]';
+        return false;
+      }
+      element.forEach(item => {
+        const visitor = YamlVisitor({
+          indent: this.indent + 1
+        });
+        const indent = this.indentChar.repeat(this.indent);
+        visit(item, visitor);
+        const {
+          result
+        } = visitor;
+        this.result += result.startsWith('\n') ? `\n${indent}-${visitor.result}` : `\n${indent}- ${visitor.result}`;
+      });
+      return false;
+    },
+    ObjectElement(element) {
+      if (element.length === 0) {
+        this.result += '{}';
+        return false;
+      }
+      element.forEach((value, key) => {
+        const keyVisitor = YamlVisitor({
+          indent: this.indent + 1
+        });
+        const valueVisitor = YamlVisitor({
+          indent: this.indent + 1
+        });
+        const indent = this.indentChar.repeat(this.indent);
+        visit(key, keyVisitor);
+        visit(value, valueVisitor);
+        const {
+          result: keyResult
+        } = keyVisitor;
+        const {
+          result: valueResult
+        } = valueVisitor;
+        this.result += valueResult.startsWith('\n') ? `\n${indent}${keyResult}:${valueResult}` : `\n${indent}${keyResult}: ${valueResult}`;
+      });
+      return false;
+    }
+  }
+});
+const serializer = element => {
+  const signature = '%YAML 1.2\n---\n';
+  const visitor = YamlVisitor({
+    signature
+  });
+  visit(element, visitor);
+  return visitor.result;
+};
+export default serializer;

package/es/sexprs.js

@@ -0,0 +1,32 @@
+import stampit from 'stampit';
+import { visit } from "./traversal/visitor.js";
+const SymbolicExpressionsVisitor = stampit({
+  props: {
+    nestingLevel: 0,
+    result: ''
+  },
+  methods: {
+    enter(element) {
+      const {
+        element: elementName
+      } = element;
+      const capitalizedElementName = elementName.charAt(0).toUpperCase() + elementName.slice(1);
+      const indent = '  '.repeat(this.nestingLevel);
+      this.result += this.nestingLevel > 0 ? '\n' : '';
+      this.result += `${indent}(${capitalizedElementName}Element`;
+      this.nestingLevel += 1;
+    },
+    leave() {
+      this.nestingLevel -= 1;
+      this.result += ')';
+    }
+  }
+});
+
+// transforms ApiDOM into S-expressions (Symbolic Expressions)
+const sexprs = element => {
+  const visitor = SymbolicExpressionsVisitor();
+  visit(element, visitor);
+  return visitor.result;
+};
+export default sexprs;