@swagger-api/apidom-ast 0.68.0

package/es/traversal/visitor.js

@@ -0,0 +1,483 @@
+/**
+ * SPDX-FileCopyrightText: Copyright (c) GraphQL Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+// getVisitFn :: (Visitor, String, Boolean) -> Function
+export 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;
+};
+export const BREAK = {};
+
+// getNodeType :: Node -> String
+export const getNodeType = node => node === null || node === void 0 ? void 0 : node.type;
+
+// isNode :: Node -> Boolean
+export 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.
+ */
+export 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 }
+ */
+export 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
+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/es/yaml/nodes/YamlAlias.js

@@ -0,0 +1,16 @@
+import stampit from 'stampit';
+import Node from "../../Node.js";
+const YamlAlias = stampit(Node, {
+  statics: {
+    type: 'alias'
+  },
+  props: {
+    content: null
+  },
+  init({
+    content = null
+  } = {}) {
+    this.content = content;
+  }
+});
+export default YamlAlias;

package/es/yaml/nodes/YamlAnchor.js

@@ -0,0 +1,16 @@
+import stampit from 'stampit';
+import Node from "../../Node.js";
+const YamlAnchor = stampit(Node, {
+  statics: {
+    type: 'anchor'
+  },
+  props: {
+    name: null
+  },
+  init({
+    name = null
+  } = {}) {
+    this.name = name;
+  }
+});
+export default YamlAnchor;

package/es/yaml/nodes/YamlCollection.js

@@ -0,0 +1,4 @@
+import stampit from 'stampit';
+import YamlNode from "./YamlNode.js";
+const YamlCollection = stampit(YamlNode, {});
+export default YamlCollection;

package/es/yaml/nodes/YamlComment.js

@@ -0,0 +1,16 @@
+import stampit from 'stampit';
+import Node from "../../Node.js";
+const YamlComment = stampit(Node, {
+  statics: {
+    type: 'comment'
+  },
+  props: {
+    content: null
+  },
+  init({
+    content = null
+  } = {}) {
+    this.content = content;
+  }
+});
+export default YamlComment;

package/es/yaml/nodes/YamlDirective.js

@@ -0,0 +1,24 @@
+import stampit from 'stampit';
+import { mergeRight } from 'ramda';
+import Node from "../../Node.js";
+const YamlDirective = stampit(Node, {
+  statics: {
+    type: 'directive'
+  },
+  props: {
+    name: null,
+    parameters: null
+  },
+  init({
+    name = null,
+    parameters = {}
+  } = {}) {
+    this.name = name;
+    this.parameters = mergeRight({
+      version: null,
+      handle: null,
+      prefix: null
+    }, parameters);
+  }
+});
+export default YamlDirective;

package/es/yaml/nodes/YamlDocument.js

@@ -0,0 +1,8 @@
+import stampit from 'stampit';
+import Node from "../../Node.js";
+const YamlDocument = stampit(Node, {
+  statics: {
+    type: 'document'
+  }
+});
+export default YamlDocument;

package/es/yaml/nodes/YamlKeyValuePair.js

@@ -0,0 +1,34 @@
+import stampit from 'stampit';
+import Node from "../../Node.js";
+import YamlStyleModel from "./YamlStyle.js";
+import { isScalar, isMapping, isSequence, isAlias } from "./predicates.js";
+const YamlKeyValuePair = stampit(Node, YamlStyleModel, {
+  statics: {
+    type: 'keyValuePair'
+  },
+  propertyDescriptors: {
+    key: {
+      get() {
+        // @ts-ignore
+        return this.children.filter(node => isScalar(node) || isMapping(node) || isSequence(node))[0];
+      },
+      enumerable: true
+    },
+    value: {
+      get() {
+        // @ts-ignore
+        const {
+          key,
+          children
+        } = this;
+        const excludeKeyPredicate = node => node !== key;
+        const valuePredicate = node => isScalar(node) || isMapping(node) || isSequence(node) || isAlias(node);
+
+        // @ts-ignore
+        return children.filter(node => excludeKeyPredicate(node) && valuePredicate(node))[0];
+      },
+      enumerable: true
+    }
+  }
+});
+export default YamlKeyValuePair;

package/es/yaml/nodes/YamlMapping.js

@@ -0,0 +1,18 @@
+import stampit from 'stampit';
+import YamlCollection from "./YamlCollection.js";
+import { isKeyValuePair } from "./predicates.js";
+const YamlMapping = stampit(YamlCollection, {
+  statics: {
+    type: 'mapping'
+  },
+  propertyDescriptors: {
+    content: {
+      get() {
+        // @ts-ignore
+        return Array.isArray(this.children) ? this.children.filter(isKeyValuePair) : [];
+      },
+      enumerable: true
+    }
+  }
+});
+export default YamlMapping;

package/es/yaml/nodes/YamlNode.js

@@ -0,0 +1,22 @@
+import stampit from 'stampit';
+import Node from "../../Node.js";
+const YamlNode = stampit(Node, {
+  props: {
+    anchor: null,
+    tag: null,
+    style: null,
+    styleGroup: null
+  },
+  init({
+    anchor = null,
+    tag = null,
+    style = null,
+    styleGroup = null
+  } = {}) {
+    this.anchor = anchor;
+    this.tag = tag;
+    this.style = style;
+    this.styleGroup = styleGroup;
+  }
+});
+export default YamlNode;

package/es/yaml/nodes/YamlScalar.js

@@ -0,0 +1,16 @@
+import stampit from 'stampit';
+import YamlNode from "./YamlNode.js";
+const YamlScalar = stampit(YamlNode, {
+  statics: {
+    type: 'scalar'
+  },
+  props: {
+    content: ''
+  },
+  init({
+    content
+  } = {}) {
+    this.content = content;
+  }
+});
+export default YamlScalar;

package/es/yaml/nodes/YamlSequence.js

@@ -0,0 +1,21 @@
+import stampit from 'stampit';
+import YamlCollection from "./YamlCollection.js";
+import { isMapping, isScalar, isSequence, isAlias } from "./predicates.js";
+const YamlSequence = stampit(YamlCollection, {
+  statics: {
+    type: 'sequence'
+  },
+  propertyDescriptors: {
+    content: {
+      get() {
+        // @ts-ignore
+        const {
+          children
+        } = this;
+        return Array.isArray(children) ? children.filter(node => isSequence(node) || isMapping(node) || isScalar(node) || isAlias(node)) : [];
+      },
+      enumerable: true
+    }
+  }
+});
+export default YamlSequence;