@swagger-api/apidom-ast 0.68.0

package/cjs/json/nodes/predicates.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isTrue = exports.isStringContent = exports.isString = exports.isProperty = exports.isObject = exports.isNumber = exports.isNull = exports.isKey = exports.isFalse = exports.isEscapeSequence = exports.isDocument = exports.isArray = void 0;
+var _predicates = require("../../predicates.cjs");
+const isDocument = _predicates.isNodeType.bind(undefined, 'document');
+exports.isDocument = isDocument;
+const isString = _predicates.isNodeType.bind(undefined, 'string');
+exports.isString = isString;
+const isFalse = _predicates.isNodeType.bind(undefined, 'false');
+exports.isFalse = isFalse;
+const isTrue = _predicates.isNodeType.bind(undefined, 'true');
+exports.isTrue = isTrue;
+const isNull = _predicates.isNodeType.bind(undefined, 'null');
+exports.isNull = isNull;
+const isNumber = _predicates.isNodeType.bind(undefined, 'number');
+exports.isNumber = isNumber;
+const isArray = _predicates.isNodeType.bind(undefined, 'array');
+exports.isArray = isArray;
+const isObject = _predicates.isNodeType.bind(undefined, 'object');
+exports.isObject = isObject;
+const isStringContent = _predicates.isNodeType.bind(undefined, 'stringContent');
+exports.isStringContent = isStringContent;
+const isEscapeSequence = _predicates.isNodeType.bind(undefined, 'escapeSequence');
+exports.isEscapeSequence = isEscapeSequence;
+const isProperty = _predicates.isNodeType.bind(undefined, 'property');
+exports.isProperty = isProperty;
+const isKey = _predicates.isNodeType.bind(undefined, 'key');
+exports.isKey = isKey;

package/cjs/predicates.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isPosition = exports.isPoint = exports.isParseResult = exports.isNodeType = exports.isLiteral = void 0;
+const isNodeType = (type, node) => (node === null || node === void 0 ? void 0 : node.type) === type;
+exports.isNodeType = isNodeType;
+const isLiteral = isNodeType.bind(undefined, 'literal');
+exports.isLiteral = isLiteral;
+const isPosition = isNodeType.bind(undefined, 'position');
+exports.isPosition = isPosition;
+const isPoint = isNodeType.bind(undefined, 'point');
+exports.isPoint = isPoint;
+const isParseResult = isNodeType.bind(undefined, 'parseResult');
+exports.isParseResult = isParseResult;

package/cjs/traversal/visitor.cjs

@@ -0,0 +1,493 @@
+"use strict";
+
+exports.__esModule = true;
+exports.visit = exports.mergeAll = exports.isNode = exports.getVisitFn = exports.getNodeType = exports.BREAK = void 0;
+/**
+ * SPDX-FileCopyrightText: Copyright (c) GraphQL Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+// getVisitFn :: (Visitor, String, Boolean) -> Function
+const getVisitFn = (visitor, type, isLeaving) => {
+  const typeVisitor = visitor[type];
+  if (typeVisitor != null) {
+    if (!isLeaving && typeof typeVisitor === 'function') {
+      // { Type() {} }
+      return typeVisitor;
+    }
+    const typeSpecificVisitor = isLeaving ? typeVisitor.leave : typeVisitor.enter;
+    if (typeof typeSpecificVisitor === 'function') {
+      // { Type: { enter() {}, leave() {} } }
+      return typeSpecificVisitor;
+    }
+  } else {
+    const specificVisitor = isLeaving ? visitor.leave : visitor.enter;
+    if (specificVisitor != null) {
+      if (typeof specificVisitor === 'function') {
+        // { enter() {}, leave() {} }
+        return specificVisitor;
+      }
+      const specificTypeVisitor = specificVisitor[type];
+      if (typeof specificTypeVisitor === 'function') {
+        // { enter: { Type() {} }, leave: { Type() {} } }
+        return specificTypeVisitor;
+      }
+    }
+  }
+  return null;
+};
+exports.getVisitFn = getVisitFn;
+const BREAK = {};
+
+// getNodeType :: Node -> String
+exports.BREAK = BREAK;
+const getNodeType = node => node === null || node === void 0 ? void 0 : node.type;
+
+// isNode :: Node -> Boolean
+exports.getNodeType = getNodeType;
+const isNode = node => typeof getNodeType(node) === 'string';
+
+/**
+ * Creates a new visitor instance which delegates to many visitors to run in
+ * parallel. Each visitor will be visited for each node before moving on.
+ *
+ * If a prior visitor edits a node, no following visitors will see that node.
+ */
+exports.isNode = isNode;
+const mergeAll = (visitors, {
+  visitFnGetter = getVisitFn,
+  nodeTypeGetter = getNodeType
+} = {}) => {
+  const skipping = new Array(visitors.length);
+  return {
+    enter(node, ...rest) {
+      for (let i = 0; i < visitors.length; i += 1) {
+        if (skipping[i] == null) {
+          const fn = visitFnGetter(visitors[i], nodeTypeGetter(node), /* isLeaving */false);
+          if (typeof fn === 'function') {
+            const result = fn.call(visitors[i], node, ...rest);
+            if (result === false) {
+              skipping[i] = node;
+            } else if (result === BREAK) {
+              skipping[i] = BREAK;
+            } else if (result !== undefined) {
+              return result;
+            }
+          }
+        }
+      }
+      return undefined;
+    },
+    leave(node, ...rest) {
+      for (let i = 0; i < visitors.length; i += 1) {
+        if (skipping[i] == null) {
+          const fn = visitFnGetter(visitors[i], nodeTypeGetter(node), /* isLeaving */true);
+          if (typeof fn === 'function') {
+            const result = fn.call(visitors[i], node, ...rest);
+            if (result === BREAK) {
+              skipping[i] = BREAK;
+            } else if (result !== undefined && result !== false) {
+              return result;
+            }
+          }
+        } else if (skipping[i] === node) {
+          skipping[i] = null;
+        }
+      }
+      return undefined;
+    }
+  };
+};
+
+/* eslint-disable no-continue, no-nested-ternary, no-param-reassign */
+/**
+ * visit() will walk through an AST using a preorder depth first traversal, calling
+ * the visitor's enter function at each node in the traversal, and calling the
+ * leave function after visiting that node and all of its child nodes.
+ *
+ * By returning different values from the enter and leave functions, the
+ * behavior of the visitor can be altered, including skipping over a sub-tree of
+ * the AST (by returning false), editing the AST by returning a value or null
+ * to remove the value, or to stop the whole traversal by returning BREAK.
+ *
+ * When using visit() to edit an AST, the original AST will not be modified, and
+ * a new version of the AST with the changes applied will be returned from the
+ * visit function.
+ *
+ *     const editedAST = visit(ast, {
+ *       enter(node, key, parent, path, ancestors) {
+ *         // @return
+ *         //   undefined: no action
+ *         //   false: skip visiting this node
+ *         //   BREAK: stop visiting altogether
+ *         //   null: delete this node
+ *         //   any value: replace this node with the returned value
+ *       },
+ *       leave(node, key, parent, path, ancestors) {
+ *         // @return
+ *         //   undefined: no action
+ *         //   false: no action
+ *         //   BREAK: stop visiting altogether
+ *         //   null: delete this node
+ *         //   any value: replace this node with the returned value
+ *       }
+ *     });
+ *
+ * Alternatively to providing enter() and leave() functions, a visitor can
+ * instead provide functions named the same as the kinds of AST nodes, or
+ * enter/leave visitors at a named key, leading to four permutations of
+ * visitor API:
+ *
+ * 1) Named visitors triggered when entering a node a specific kind.
+ *
+ *     visit(ast, {
+ *       Kind(node) {
+ *         // enter the "Kind" node
+ *       }
+ *     })
+ *
+ * 2) Named visitors that trigger upon entering and leaving a node of
+ *    a specific kind.
+ *
+ *     visit(ast, {
+ *       Kind: {
+ *         enter(node) {
+ *           // enter the "Kind" node
+ *         }
+ *         leave(node) {
+ *           // leave the "Kind" node
+ *         }
+ *       }
+ *     })
+ *
+ * 3) Generic visitors that trigger upon entering and leaving any node.
+ *
+ *     visit(ast, {
+ *       enter(node) {
+ *         // enter any node
+ *       },
+ *       leave(node) {
+ *         // leave any node
+ *       }
+ *     })
+ *
+ * 4) Parallel visitors for entering and leaving nodes of a specific kind.
+ *
+ *     visit(ast, {
+ *       enter: {
+ *         Kind(node) {
+ *           // enter the "Kind" node
+ *         }
+ *       },
+ *       leave: {
+ *         Kind(node) {
+ *           // leave the "Kind" node
+ *         }
+ *       }
+ *     })
+ *
+ *  @sig visit :: (Node, Visitor, Options)
+ *  @sig      Options = { keyMap: Object, state: Object }
+ */
+exports.mergeAll = mergeAll;
+const visit = (
+// @ts-ignore
+root,
+// @ts-ignore
+visitor, {
+  keyMap = null,
+  state = {},
+  breakSymbol = BREAK,
+  deleteNodeSymbol = null,
+  skipVisitingNodeSymbol = false,
+  visitFnGetter = getVisitFn,
+  nodeTypeGetter = getNodeType,
+  nodePredicate = isNode,
+  detectCycles = true
+} = {}) => {
+  const visitorKeys = keyMap || {};
+  let stack;
+  let inArray = Array.isArray(root);
+  let keys = [root];
+  let index = -1;
+  let parent;
+  let edits = [];
+  const path = [];
+  // @ts-ignore
+  const ancestors = [];
+  let newRoot = root;
+  do {
+    index += 1;
+    const isLeaving = index === keys.length;
+    let key;
+    let node;
+    const isEdited = isLeaving && edits.length !== 0;
+    if (isLeaving) {
+      key = ancestors.length === 0 ? undefined : path.pop();
+      node = parent;
+      // @ts-ignore
+      parent = ancestors.pop();
+      if (isEdited) {
+        if (inArray) {
+          // @ts-ignore
+          node = node.slice();
+        } else {
+          // creating clone
+          node = Object.create(Object.getPrototypeOf(node), Object.getOwnPropertyDescriptors(node));
+        }
+        let editOffset = 0;
+        for (let ii = 0; ii < edits.length; ii += 1) {
+          let editKey = edits[ii][0];
+          const editValue = edits[ii][1];
+          if (inArray) {
+            editKey -= editOffset;
+          }
+          if (inArray && editValue === deleteNodeSymbol) {
+            node.splice(editKey, 1);
+            editOffset += 1;
+          } else {
+            node[editKey] = editValue;
+          }
+        }
+      }
+      index = stack.index;
+      keys = stack.keys;
+      // @ts-ignore
+      edits = stack.edits;
+      // @ts-ignore
+      inArray = stack.inArray;
+      // @ts-ignore
+      stack = stack.prev;
+    } else {
+      key = parent ? inArray ? index : keys[index] : undefined;
+      node = parent ? parent[key] : newRoot;
+      if (node === deleteNodeSymbol || node === undefined) {
+        continue;
+      }
+      if (parent) {
+        path.push(key);
+      }
+    }
+    if (ancestors.includes(node)) {
+      continue;
+    }
+    let result;
+    if (!Array.isArray(node)) {
+      if (!nodePredicate(node)) {
+        throw new Error(`Invalid AST Node:  ${JSON.stringify(node)}`);
+      }
+      // cycle detected; skipping over a sub-tree to avoid recursion
+      if (detectCycles && ancestors.includes(node)) {
+        path.pop();
+        continue;
+      }
+      // call appropriate visitor function if available
+      const visitFn = visitFnGetter(visitor, nodeTypeGetter(node), isLeaving);
+      if (visitFn) {
+        // assign state
+        for (const [stateKey, stateValue] of Object.entries(state)) {
+          visitor[stateKey] = stateValue;
+        }
+        result = visitFn.call(visitor, node, key, parent, path, ancestors);
+        if (result === breakSymbol) {
+          break;
+        }
+        if (result === skipVisitingNodeSymbol) {
+          if (!isLeaving) {
+            path.pop();
+            continue;
+          }
+        } else if (result !== undefined) {
+          edits.push([key, result]);
+          if (!isLeaving) {
+            if (nodePredicate(result)) {
+              node = result;
+            } else {
+              path.pop();
+              continue;
+            }
+          }
+        }
+      }
+    }
+    if (result === undefined && isEdited) {
+      edits.push([key, node]);
+    }
+    if (!isLeaving) {
+      stack = {
+        inArray,
+        index,
+        keys,
+        edits,
+        prev: stack
+      };
+      inArray = Array.isArray(node);
+      // @ts-ignore
+      keys = inArray ? node : visitorKeys[nodeTypeGetter(node)] || [];
+      index = -1;
+      edits = [];
+      if (parent) {
+        ancestors.push(parent);
+      }
+      parent = node;
+    }
+  } while (stack !== undefined);
+  if (edits.length !== 0) {
+    [, newRoot] = edits[edits.length - 1];
+  }
+  return newRoot;
+};
+
+/**
+ * Asynchronous version of visit.
+ */
+// @ts-ignore
+exports.visit = visit;
+visit[Symbol.for('nodejs.util.promisify.custom')] = async (
+// @ts-ignore
+root,
+// @ts-ignore
+visitor, {
+  keyMap = null,
+  state = {},
+  breakSymbol = BREAK,
+  deleteNodeSymbol = null,
+  skipVisitingNodeSymbol = false,
+  visitFnGetter = getVisitFn,
+  nodeTypeGetter = getNodeType,
+  nodePredicate = isNode,
+  detectCycles = true
+} = {}) => {
+  const visitorKeys = keyMap || {};
+  let stack;
+  let inArray = Array.isArray(root);
+  let keys = [root];
+  let index = -1;
+  let parent;
+  let edits = [];
+  const path = [];
+  // @ts-ignore
+  const ancestors = [];
+  let newRoot = root;
+  do {
+    index += 1;
+    const isLeaving = index === keys.length;
+    let key;
+    let node;
+    const isEdited = isLeaving && edits.length !== 0;
+    if (isLeaving) {
+      key = ancestors.length === 0 ? undefined : path.pop();
+      node = parent;
+      // @ts-ignore
+      parent = ancestors.pop();
+      if (isEdited) {
+        if (inArray) {
+          // @ts-ignore
+          node = node.slice();
+        } else {
+          // creating clone
+          node = Object.create(Object.getPrototypeOf(node), Object.getOwnPropertyDescriptors(node));
+        }
+        let editOffset = 0;
+        for (let ii = 0; ii < edits.length; ii += 1) {
+          let editKey = edits[ii][0];
+          const editValue = edits[ii][1];
+          if (inArray) {
+            editKey -= editOffset;
+          }
+          if (inArray && editValue === deleteNodeSymbol) {
+            node.splice(editKey, 1);
+            editOffset += 1;
+          } else {
+            node[editKey] = editValue;
+          }
+        }
+      }
+      index = stack.index;
+      keys = stack.keys;
+      // @ts-ignore
+      edits = stack.edits;
+      // @ts-ignore
+      inArray = stack.inArray;
+      // @ts-ignore
+      stack = stack.prev;
+    } else {
+      key = parent ? inArray ? index : keys[index] : undefined;
+      node = parent ? parent[key] : newRoot;
+      if (node === deleteNodeSymbol || node === undefined) {
+        continue;
+      }
+      if (parent) {
+        path.push(key);
+      }
+    }
+    let result;
+    if (!Array.isArray(node)) {
+      if (!nodePredicate(node)) {
+        throw new Error(`Invalid AST Node:  ${JSON.stringify(node)}`);
+      }
+      // cycle detected; skipping over a sub-tree to avoid recursion
+      if (detectCycles && ancestors.includes(node)) {
+        path.pop();
+        continue;
+      }
+      const visitFn = visitFnGetter(visitor, nodeTypeGetter(node), isLeaving);
+      if (visitFn) {
+        // assign state
+        for (const [stateKey, stateValue] of Object.entries(state)) {
+          visitor[stateKey] = stateValue;
+        }
+
+        // eslint-disable-next-line no-await-in-loop
+        result = await visitFn.call(visitor, node, key, parent, path, ancestors);
+        if (result === breakSymbol) {
+          break;
+        }
+        if (result === skipVisitingNodeSymbol) {
+          if (!isLeaving) {
+            path.pop();
+            continue;
+          }
+        } else if (result !== undefined) {
+          edits.push([key, result]);
+          if (!isLeaving) {
+            if (nodePredicate(result)) {
+              node = result;
+            } else {
+              path.pop();
+              continue;
+            }
+          }
+        }
+      }
+    }
+    if (result === undefined && isEdited) {
+      edits.push([key, node]);
+    }
+    if (!isLeaving) {
+      stack = {
+        inArray,
+        index,
+        keys,
+        edits,
+        prev: stack
+      };
+      inArray = Array.isArray(node);
+      // @ts-ignore
+      keys = inArray ? node : visitorKeys[nodeTypeGetter(node)] || [];
+      index = -1;
+      edits = [];
+      if (parent) {
+        ancestors.push(parent);
+      }
+      parent = node;
+    }
+  } while (stack !== undefined);
+  if (edits.length !== 0) {
+    [, newRoot] = edits[edits.length - 1];
+  }
+  return newRoot;
+};
+
+/* eslint-enable */

package/cjs/yaml/nodes/YamlAlias.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _stampit = _interopRequireDefault(require("stampit"));
+var _Node = _interopRequireDefault(require("../../Node.cjs"));
+const YamlAlias = (0, _stampit.default)(_Node.default, {
+  statics: {
+    type: 'alias'
+  },
+  props: {
+    content: null
+  },
+  init({
+    content = null
+  } = {}) {
+    this.content = content;
+  }
+});
+var _default = YamlAlias;
+exports.default = _default;

package/cjs/yaml/nodes/YamlAnchor.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _stampit = _interopRequireDefault(require("stampit"));
+var _Node = _interopRequireDefault(require("../../Node.cjs"));
+const YamlAnchor = (0, _stampit.default)(_Node.default, {
+  statics: {
+    type: 'anchor'
+  },
+  props: {
+    name: null
+  },
+  init({
+    name = null
+  } = {}) {
+    this.name = name;
+  }
+});
+var _default = YamlAnchor;
+exports.default = _default;

package/cjs/yaml/nodes/YamlCollection.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _stampit = _interopRequireDefault(require("stampit"));
+var _YamlNode = _interopRequireDefault(require("./YamlNode.cjs"));
+const YamlCollection = (0, _stampit.default)(_YamlNode.default, {});
+var _default = YamlCollection;
+exports.default = _default;

package/cjs/yaml/nodes/YamlComment.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _stampit = _interopRequireDefault(require("stampit"));
+var _Node = _interopRequireDefault(require("../../Node.cjs"));
+const YamlComment = (0, _stampit.default)(_Node.default, {
+  statics: {
+    type: 'comment'
+  },
+  props: {
+    content: null
+  },
+  init({
+    content = null
+  } = {}) {
+    this.content = content;
+  }
+});
+var _default = YamlComment;
+exports.default = _default;

package/cjs/yaml/nodes/YamlDirective.cjs

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _stampit = _interopRequireDefault(require("stampit"));
+var _ramda = require("ramda");
+var _Node = _interopRequireDefault(require("../../Node.cjs"));
+const YamlDirective = (0, _stampit.default)(_Node.default, {
+  statics: {
+    type: 'directive'
+  },
+  props: {
+    name: null,
+    parameters: null
+  },
+  init({
+    name = null,
+    parameters = {}
+  } = {}) {
+    this.name = name;
+    this.parameters = (0, _ramda.mergeRight)({
+      version: null,
+      handle: null,
+      prefix: null
+    }, parameters);
+  }
+});
+var _default = YamlDirective;
+exports.default = _default;

package/cjs/yaml/nodes/YamlDocument.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _stampit = _interopRequireDefault(require("stampit"));
+var _Node = _interopRequireDefault(require("../../Node.cjs"));
+const YamlDocument = (0, _stampit.default)(_Node.default, {
+  statics: {
+    type: 'document'
+  }
+});
+var _default = YamlDocument;
+exports.default = _default;

package/cjs/yaml/nodes/YamlKeyValuePair.cjs

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.default = void 0;
+var _stampit = _interopRequireDefault(require("stampit"));
+var _Node = _interopRequireDefault(require("../../Node.cjs"));
+var _YamlStyle = _interopRequireDefault(require("./YamlStyle.cjs"));
+var _predicates = require("./predicates.cjs");
+const YamlKeyValuePair = (0, _stampit.default)(_Node.default, _YamlStyle.default, {
+  statics: {
+    type: 'keyValuePair'
+  },
+  propertyDescriptors: {
+    key: {
+      get() {
+        // @ts-ignore
+        return this.children.filter(node => (0, _predicates.isScalar)(node) || (0, _predicates.isMapping)(node) || (0, _predicates.isSequence)(node))[0];
+      },
+      enumerable: true
+    },
+    value: {
+      get() {
+        // @ts-ignore
+        const {
+          key,
+          children
+        } = this;
+        const excludeKeyPredicate = node => node !== key;
+        const valuePredicate = node => (0, _predicates.isScalar)(node) || (0, _predicates.isMapping)(node) || (0, _predicates.isSequence)(node) || (0, _predicates.isAlias)(node);
+
+        // @ts-ignore
+        return children.filter(node => excludeKeyPredicate(node) && valuePredicate(node))[0];
+      },
+      enumerable: true
+    }
+  }
+});
+var _default = YamlKeyValuePair;
+exports.default = _default;