@speclynx/apidom-core 1.12.1

package/src/transformers/serializers/value/index.cjs

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _visitor = require("./visitor.cjs");
+var _ephemeralArray = _interopRequireDefault(require("./ast/ephemeral-array.cjs"));
+var _ephemeralObject = _interopRequireDefault(require("./ast/ephemeral-object.cjs"));
+var _index = require("../../../predicates/index.cjs");
+class Visitor {
+  ObjectElement = {
+    enter: element => {
+      if (this.references.has(element)) {
+        return this.references.get(element).toReference();
+      }
+      const ephemeral = new _ephemeralObject.default(element.content);
+      this.references.set(element, ephemeral);
+      return ephemeral;
+    }
+  };
+  EphemeralObject = {
+    leave: ephemeral => {
+      return ephemeral.toObject();
+    }
+  };
+  MemberElement = {
+    enter: element => {
+      return [element.key, element.value];
+    }
+  };
+  ArrayElement = {
+    enter: element => {
+      if (this.references.has(element)) {
+        return this.references.get(element).toReference();
+      }
+      const ephemeral = new _ephemeralArray.default(element.content);
+      this.references.set(element, ephemeral);
+      return ephemeral;
+    }
+  };
+  EphemeralArray = {
+    leave: ephemeral => {
+      return ephemeral.toArray();
+    }
+  };
+  references = new WeakMap();
+  BooleanElement(element) {
+    return element.toValue();
+  }
+  NumberElement(element) {
+    return element.toValue();
+  }
+  StringElement(element) {
+    return element.toValue();
+  }
+  NullElement() {
+    return null;
+  }
+  RefElement(element, ...rest) {
+    const ancestors = rest[3];
+    if (ancestors[ancestors.length - 1]?.type === 'EphemeralObject') {
+      return Symbol.for('delete-node');
+    }
+    return String(element.toValue());
+  }
+  LinkElement(element) {
+    if ((0, _index.isStringElement)(element.href)) {
+      return element.href.toValue();
+    }
+    return '';
+  }
+}
+/**
+ * @public
+ */
+const serializer = element => {
+  if (!(0, _index.isElement)(element)) return element;
+
+  // shortcut optimization for certain element types
+  if ((0, _index.isStringElement)(element) || (0, _index.isNumberElement)(element) || (0, _index.isBooleanElement)(element) || (0, _index.isNullElement)(element)) {
+    return element.toValue();
+  }
+  return (0, _visitor.visit)(element, new Visitor());
+};
+var _default = exports.default = serializer;

package/src/transformers/serializers/value/index.mjs

@@ -0,0 +1,80 @@
+import { visit } from "./visitor.mjs";
+import EphemeralArray from "./ast/ephemeral-array.mjs";
+import EphemeralObject from "./ast/ephemeral-object.mjs";
+import { isElement, isBooleanElement, isNumberElement, isStringElement, isNullElement } from "../../../predicates/index.mjs";
+class Visitor {
+  ObjectElement = {
+    enter: element => {
+      if (this.references.has(element)) {
+        return this.references.get(element).toReference();
+      }
+      const ephemeral = new EphemeralObject(element.content);
+      this.references.set(element, ephemeral);
+      return ephemeral;
+    }
+  };
+  EphemeralObject = {
+    leave: ephemeral => {
+      return ephemeral.toObject();
+    }
+  };
+  MemberElement = {
+    enter: element => {
+      return [element.key, element.value];
+    }
+  };
+  ArrayElement = {
+    enter: element => {
+      if (this.references.has(element)) {
+        return this.references.get(element).toReference();
+      }
+      const ephemeral = new EphemeralArray(element.content);
+      this.references.set(element, ephemeral);
+      return ephemeral;
+    }
+  };
+  EphemeralArray = {
+    leave: ephemeral => {
+      return ephemeral.toArray();
+    }
+  };
+  references = new WeakMap();
+  BooleanElement(element) {
+    return element.toValue();
+  }
+  NumberElement(element) {
+    return element.toValue();
+  }
+  StringElement(element) {
+    return element.toValue();
+  }
+  NullElement() {
+    return null;
+  }
+  RefElement(element, ...rest) {
+    const ancestors = rest[3];
+    if (ancestors[ancestors.length - 1]?.type === 'EphemeralObject') {
+      return Symbol.for('delete-node');
+    }
+    return String(element.toValue());
+  }
+  LinkElement(element) {
+    if (isStringElement(element.href)) {
+      return element.href.toValue();
+    }
+    return '';
+  }
+}
+/**
+ * @public
+ */
+const serializer = element => {
+  if (!isElement(element)) return element;
+
+  // shortcut optimization for certain element types
+  if (isStringElement(element) || isNumberElement(element) || isBooleanElement(element) || isNullElement(element)) {
+    return element.toValue();
+  }
+  return visit(element, new Visitor());
+};
+export default serializer;

package/src/transformers/serializers/value/visitor.cjs

@@ -0,0 +1,52 @@
+"use strict";
+
+exports.__esModule = true;
+exports.visit = void 0;
+var _ramda = require("ramda");
+var _visitor = require("../../../traversal/visitor.cjs");
+const nodeTypeGetter = node => {
+  if (typeof node?.type === 'string') {
+    return node.type;
+  }
+  return (0, _visitor.getNodeType)(node);
+};
+const keyMapDefault = {
+  EphemeralObject: ['content'],
+  EphemeralArray: ['content'],
+  ..._visitor.keyMapDefault
+};
+const visit = (root,
+// @ts-ignore
+visitor, {
+  keyMap = keyMapDefault,
+  ...rest
+} = {}) => {
+  return (0, _visitor.visit)(root, visitor, {
+    keyMap,
+    // @ts-ignore
+    nodeTypeGetter,
+    nodePredicate: _ramda.T,
+    detectCycles: false,
+    deleteNodeSymbol: Symbol.for('delete-node'),
+    skipVisitingNodeSymbol: Symbol.for('skip-visiting-node'),
+    ...rest
+  });
+};
+
+// @ts-ignore
+exports.visit = visit;
+visit[Symbol.for('nodejs.util.promisify.custom')] = async (root, {
+  keyMap = keyMapDefault,
+  ...rest
+} = {}) => {
+  // @ts-ignore
+  return _visitor.visit[Symbol.for('nodejs.util.promisify.custom')](root, visitor, {
+    keyMap,
+    nodeTypeGetter,
+    nodePredicate: _ramda.T,
+    detectCycles: false,
+    deleteNodeSymbol: Symbol.for('delete-node'),
+    skipVisitingNodeSymbol: Symbol.for('skip-visiting-node'),
+    ...rest
+  });
+};

package/src/transformers/serializers/value/visitor.mjs

@@ -0,0 +1,47 @@
+import { T as stubTrue } from 'ramda';
+import { visit as astVisit, keyMapDefault as baseKeyMap, getNodeType as baseGetNodeType } from "../../../traversal/visitor.mjs";
+const nodeTypeGetter = node => {
+  if (typeof node?.type === 'string') {
+    return node.type;
+  }
+  return baseGetNodeType(node);
+};
+const keyMapDefault = {
+  EphemeralObject: ['content'],
+  EphemeralArray: ['content'],
+  ...baseKeyMap
+};
+export const visit = (root,
+// @ts-ignore
+visitor, {
+  keyMap = keyMapDefault,
+  ...rest
+} = {}) => {
+  return astVisit(root, visitor, {
+    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, {
+  keyMap = keyMapDefault,
+  ...rest
+} = {}) => {
+  // @ts-ignore
+  return astVisit[Symbol.for('nodejs.util.promisify.custom')](root, visitor, {
+    keyMap,
+    nodeTypeGetter,
+    nodePredicate: stubTrue,
+    detectCycles: false,
+    deleteNodeSymbol: Symbol.for('delete-node'),
+    skipVisitingNodeSymbol: Symbol.for('skip-visiting-node'),
+    ...rest
+  });
+};

package/src/transformers/serializers/yaml-1-2.cjs

@@ -0,0 +1,90 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _visitor = require("../../traversal/visitor.cjs");
+var _index = _interopRequireDefault(require("./value/index.cjs"));
+class YamlVisitor {
+  static indentChar = '  ';
+  result;
+  indent;
+  constructor({
+    directive = false,
+    indent = 0
+  } = {}) {
+    this.result = directive ? '%YAML 1.2\n---\n' : '';
+    this.indent = indent;
+  }
+  NumberElement(element) {
+    this.result += (0, _index.default)(element);
+  }
+  BooleanElement(element) {
+    const value = (0, _index.default)(element);
+    this.result += value ? 'true' : 'false';
+  }
+  StringElement(element) {
+    // for simplicity and avoiding ambiguity we always wrap strings in quotes
+    this.result += JSON.stringify((0, _index.default)(element));
+  }
+  NullElement() {
+    this.result += 'null';
+  }
+  ArrayElement(element) {
+    if (element.length === 0) {
+      this.result += '[]';
+      return false;
+    }
+    element.forEach(item => {
+      const visitor = new YamlVisitor({
+        indent: this.indent + 1
+      });
+      const indent = YamlVisitor.indentChar.repeat(this.indent);
+      (0, _visitor.visit)(item, visitor);
+      const {
+        result
+      } = visitor;
+      this.result += result.startsWith('\n') ? `\n${indent}-${result}` : `\n${indent}- ${result}`;
+    });
+    return false;
+  }
+  ObjectElement(element) {
+    if (element.length === 0) {
+      this.result += '{}';
+      return false;
+    }
+    element.forEach((value, key) => {
+      const keyVisitor = new YamlVisitor({
+        indent: this.indent + 1
+      });
+      const valueVisitor = new YamlVisitor({
+        indent: this.indent + 1
+      });
+      const indent = YamlVisitor.indentChar.repeat(this.indent);
+      (0, _visitor.visit)(key, keyVisitor);
+      (0, _visitor.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;
+  }
+}
+
+/**
+ * @public
+ */
+const serializer = (element, {
+  directive = false
+} = {}) => {
+  const visitor = new YamlVisitor({
+    directive
+  });
+  (0, _visitor.visit)(element, visitor);
+  return visitor.result;
+};
+var _default = exports.default = serializer;

package/src/transformers/serializers/yaml-1-2.mjs

@@ -0,0 +1,85 @@
+import { visit } from "../../traversal/visitor.mjs";
+import serializeValue from "./value/index.mjs";
+class YamlVisitor {
+  static indentChar = '  ';
+  result;
+  indent;
+  constructor({
+    directive = false,
+    indent = 0
+  } = {}) {
+    this.result = directive ? '%YAML 1.2\n---\n' : '';
+    this.indent = indent;
+  }
+  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 = new YamlVisitor({
+        indent: this.indent + 1
+      });
+      const indent = YamlVisitor.indentChar.repeat(this.indent);
+      visit(item, visitor);
+      const {
+        result
+      } = visitor;
+      this.result += result.startsWith('\n') ? `\n${indent}-${result}` : `\n${indent}- ${result}`;
+    });
+    return false;
+  }
+  ObjectElement(element) {
+    if (element.length === 0) {
+      this.result += '{}';
+      return false;
+    }
+    element.forEach((value, key) => {
+      const keyVisitor = new YamlVisitor({
+        indent: this.indent + 1
+      });
+      const valueVisitor = new YamlVisitor({
+        indent: this.indent + 1
+      });
+      const indent = YamlVisitor.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;
+  }
+}
+
+/**
+ * @public
+ */
+const serializer = (element, {
+  directive = false
+} = {}) => {
+  const visitor = new YamlVisitor({
+    directive
+  });
+  visit(element, visitor);
+  return visitor.result;
+};
+export default serializer;

package/src/transformers/sexprs.cjs

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _visitor = require("../traversal/visitor.cjs");
+class SymbolicExpressionsVisitor {
+  result = '';
+  nestingLevel = 0;
+  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).
+ * @public
+ */
+const sexprs = element => {
+  const visitor = new SymbolicExpressionsVisitor();
+  (0, _visitor.visit)(element, visitor);
+  return visitor.result;
+};
+var _default = exports.default = sexprs;

package/src/transformers/sexprs.mjs

@@ -0,0 +1,30 @@
+import { visit } from "../traversal/visitor.mjs";
+class SymbolicExpressionsVisitor {
+  result = '';
+  nestingLevel = 0;
+  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).
+ * @public
+ */
+const sexprs = element => {
+  const visitor = new SymbolicExpressionsVisitor();
+  visit(element, visitor);
+  return visitor.result;
+};
+export default sexprs;

package/src/transformers/to-string.cjs

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _namespace = _interopRequireDefault(require("../namespace.cjs"));
+var _dehydrate = _interopRequireDefault(require("./dehydrate.cjs"));
+/**
+ * Create a refracted string representation of an Element.
+ * @public
+ */
+const toString = (element, namespace = _namespace.default) => {
+  const refractStructure = (0, _dehydrate.default)(element, namespace);
+  return JSON.stringify(refractStructure);
+};
+var _default = exports.default = toString;

package/src/transformers/to-string.mjs

@@ -0,0 +1,11 @@
+import defaultNamespaceInstance from "../namespace.mjs";
+import dehydrate from "./dehydrate.mjs";
+/**
+ * Create a refracted string representation of an Element.
+ * @public
+ */
+const toString = (element, namespace = defaultNamespaceInstance) => {
+  const refractStructure = dehydrate(element, namespace);
+  return JSON.stringify(refractStructure);
+};
+export default toString;

package/src/traversal/filter.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _minim = require("minim");
+var _visitor = require("./visitor.cjs");
+/**
+ * Finds all elements matching the predicate.
+ * @public
+ */
+const filter = (predicate, element) => {
+  const visitor = new _visitor.PredicateVisitor({
+    predicate
+  });
+  (0, _visitor.visit)(element, visitor);
+  return new _minim.ArraySlice(visitor.result);
+};
+var _default = exports.default = filter;

package/src/traversal/filter.mjs

@@ -0,0 +1,14 @@
+import { ArraySlice } from 'minim';
+import { PredicateVisitor, visit } from "./visitor.mjs";
+/**
+ * Finds all elements matching the predicate.
+ * @public
+ */
+const filter = (predicate, element) => {
+  const visitor = new PredicateVisitor({
+    predicate
+  });
+  visit(element, visitor);
+  return new ArraySlice(visitor.result);
+};
+export default filter;

package/src/traversal/find.cjs

@@ -0,0 +1,19 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _visitor = require("./visitor.cjs");
+/**
+ * Find first element that satisfies the provided predicate.
+ * @public
+ */
+const find = (predicate, element) => {
+  const visitor = new _visitor.PredicateVisitor({
+    predicate,
+    returnOnTrue: _visitor.BREAK
+  });
+  (0, _visitor.visit)(element, visitor);
+  return (0, _ramda.pathOr)(undefined, [0], visitor.result);
+};
+var _default = exports.default = find;

package/src/traversal/find.mjs

@@ -0,0 +1,15 @@
+import { pathOr } from 'ramda';
+import { PredicateVisitor, BREAK, visit } from "./visitor.mjs";
+/**
+ * Find first element that satisfies the provided predicate.
+ * @public
+ */
+const find = (predicate, element) => {
+  const visitor = new PredicateVisitor({
+    predicate,
+    returnOnTrue: BREAK
+  });
+  visit(element, visitor);
+  return pathOr(undefined, [0], visitor.result);
+};
+export default find;

package/src/traversal/findAtOffset.cjs

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _ramdaAdjunct = require("ramda-adjunct");
+var _index = require("../predicates/index.cjs");
+var _visitor = require("./visitor.cjs");
+var _index2 = _interopRequireDefault(require("../transformers/serializers/value/index.cjs"));
+class Visitor {
+  result;
+  offset;
+  includeRightBound;
+  constructor({
+    offset = 0,
+    includeRightBound = false
+  } = {}) {
+    this.result = [];
+    this.offset = offset;
+    this.includeRightBound = includeRightBound;
+  }
+  enter(element) {
+    if (!(0, _index.hasElementSourceMap)(element)) {
+      return undefined; // dive in
+    }
+    const sourceMapElement = element.getMetaProperty('sourceMap');
+    const charStart = (0, _index2.default)(sourceMapElement.positionStart.get(2));
+    const charEnd = (0, _index2.default)(sourceMapElement.positionEnd.get(2));
+    const isWithinOffsetRange = this.offset >= charStart && (this.offset < charEnd || this.includeRightBound && this.offset <= charEnd);
+    if (isWithinOffsetRange) {
+      this.result.push(element);
+      return undefined; // push to stack and dive in
+    }
+    return false; // skip entire sub-tree
+  }
+}
+
+/**
+ * @public
+ */
+
+/**
+ * Finds the most inner node at the given offset.
+ * If includeRightBound is set, also finds nodes that end at the given offset.
+ * @public
+ */
+const findAtOffset = (options, element) => {
+  let offset;
+  let includeRightBound;
+  if ((0, _ramdaAdjunct.isNumber)(options)) {
+    offset = options;
+    includeRightBound = false;
+  } else {
+    offset = (0, _ramda.pathOr)(0, ['offset'], options);
+    includeRightBound = (0, _ramda.pathOr)(false, ['includeRightBound'], options);
+  }
+  const visitor = new Visitor({
+    offset,
+    includeRightBound
+  });
+  (0, _visitor.visit)(element, visitor);
+  return (0, _ramda.last)(visitor.result);
+};
+var _default = exports.default = findAtOffset;