@speclynx/apidom-core 1.12.1

package/src/traversal/findAtOffset.mjs

@@ -0,0 +1,60 @@
+import { last, pathOr } from 'ramda';
+import { isNumber } from 'ramda-adjunct';
+import { hasElementSourceMap } from "../predicates/index.mjs";
+import { visit } from "./visitor.mjs";
+import toValue from "../transformers/serializers/value/index.mjs";
+class Visitor {
+  result;
+  offset;
+  includeRightBound;
+  constructor({
+    offset = 0,
+    includeRightBound = false
+  } = {}) {
+    this.result = [];
+    this.offset = offset;
+    this.includeRightBound = includeRightBound;
+  }
+  enter(element) {
+    if (!hasElementSourceMap(element)) {
+      return undefined; // dive in
+    }
+    const sourceMapElement = element.getMetaProperty('sourceMap');
+    const charStart = toValue(sourceMapElement.positionStart.get(2));
+    const charEnd = toValue(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 (isNumber(options)) {
+    offset = options;
+    includeRightBound = false;
+  } else {
+    offset = pathOr(0, ['offset'], options);
+    includeRightBound = pathOr(false, ['includeRightBound'], options);
+  }
+  const visitor = new Visitor({
+    offset,
+    includeRightBound
+  });
+  visit(element, visitor);
+  return last(visitor.result);
+};
+export default findAtOffset;

package/src/traversal/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.traverse = exports.some = exports.reject = exports.parents = exports.findAtOffset = exports.find = exports.filter = void 0;
+var _filter = _interopRequireDefault(require("./filter.cjs"));
+exports.filter = _filter.default;
+var _find = _interopRequireDefault(require("./find.cjs"));
+exports.find = _find.default;
+var _findAtOffset = _interopRequireDefault(require("./findAtOffset.cjs"));
+exports.findAtOffset = _findAtOffset.default;
+var _reject = _interopRequireDefault(require("./reject.cjs"));
+exports.reject = _reject.default;
+var _some = _interopRequireDefault(require("./some.cjs"));
+exports.some = _some.default;
+var _traverse = _interopRequireDefault(require("./traverse.cjs"));
+exports.traverse = _traverse.default;
+var _parents = _interopRequireDefault(require("./parents.cjs"));
+exports.parents = _parents.default;

package/src/traversal/index.mjs

@@ -0,0 +1,7 @@
+export { default as filter } from "./filter.mjs";
+export { default as find } from "./find.mjs";
+export { default as findAtOffset } from "./findAtOffset.mjs";
+export { default as reject } from "./reject.mjs";
+export { default as some } from "./some.mjs";
+export { default as traverse } from "./traverse.mjs";
+export { default as parents } from "./parents.mjs";

package/src/traversal/parents.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _visitor = require("./visitor.cjs");
+class Visitor {
+  parentEdges;
+  parent;
+  constructor() {
+    this.parentEdges = new WeakMap();
+  }
+  ObjectElement(objectElement) {
+    this.parentEdges.set(objectElement, this.parent);
+    this.parent = objectElement;
+  }
+  ArrayElement(arrayElement) {
+    this.parentEdges.set(arrayElement, this.parent);
+    this.parent = arrayElement;
+  }
+  MemberElement(memberElement) {
+    this.parentEdges.set(memberElement, this.parent);
+    this.parent = memberElement;
+  }
+  enter(element) {
+    this.parentEdges.set(element, this.parent);
+  }
+}
+
+/**
+ * Computes upwards edges from every child to its parent.
+ * @public
+ */
+const parents = element => {
+  const visitor = new Visitor();
+  (0, _visitor.visit)(element, visitor);
+  return visitor.parentEdges;
+};
+var _default = exports.default = parents;

package/src/traversal/parents.mjs

@@ -0,0 +1,34 @@
+import { visit } from "./visitor.mjs";
+class Visitor {
+  parentEdges;
+  parent;
+  constructor() {
+    this.parentEdges = new WeakMap();
+  }
+  ObjectElement(objectElement) {
+    this.parentEdges.set(objectElement, this.parent);
+    this.parent = objectElement;
+  }
+  ArrayElement(arrayElement) {
+    this.parentEdges.set(arrayElement, this.parent);
+    this.parent = arrayElement;
+  }
+  MemberElement(memberElement) {
+    this.parentEdges.set(memberElement, this.parent);
+    this.parent = memberElement;
+  }
+  enter(element) {
+    this.parentEdges.set(element, this.parent);
+  }
+}
+
+/**
+ * Computes upwards edges from every child to its parent.
+ * @public
+ */
+const parents = element => {
+  const visitor = new Visitor();
+  visit(element, visitor);
+  return visitor.parentEdges;
+};
+export default parents;

package/src/traversal/reject.cjs

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramda = require("ramda");
+var _filter = _interopRequireDefault(require("./filter.cjs"));
+/**
+ * Complement of filter.
+ * @public
+ */
+const reject = (predicate, element) => {
+  return (0, _filter.default)((0, _ramda.complement)(predicate), element);
+};
+var _default = exports.default = reject;

package/src/traversal/reject.mjs

@@ -0,0 +1,10 @@
+import { complement } from 'ramda';
+import filter from "./filter.mjs";
+/**
+ * Complement of filter.
+ * @public
+ */
+const reject = (predicate, element) => {
+  return filter(complement(predicate), element);
+};
+export default reject;

package/src/traversal/some.cjs

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _ramdaAdjunct = require("ramda-adjunct");
+var _find = _interopRequireDefault(require("./find.cjs"));
+/**
+ * Tests whether at least one element passes the predicate.
+ * @public
+ */
+const some = (predicate, element) => {
+  return (0, _ramdaAdjunct.isNotUndefined)((0, _find.default)(predicate, element));
+};
+var _default = exports.default = some;

package/src/traversal/some.mjs

@@ -0,0 +1,10 @@
+import { isNotUndefined } from 'ramda-adjunct';
+import find from "./find.mjs";
+/**
+ * Tests whether at least one element passes the predicate.
+ * @public
+ */
+const some = (predicate, element) => {
+  return isNotUndefined(find(predicate, element));
+};
+export default some;

package/src/traversal/traverse.cjs

@@ -0,0 +1,60 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = exports.CallbackVisitor = void 0;
+var _ramda = require("ramda");
+var _ramdaAdjunct = require("ramda-adjunct");
+var _visitor = require("./visitor.cjs");
+var _index = require("../predicates/index.cjs");
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+class CallbackVisitor extends _visitor.PredicateVisitor {
+  callback;
+  constructor({
+    callback = _ramdaAdjunct.noop,
+    ...rest
+  } = {}) {
+    super({
+      ...rest
+    });
+    this.callback = callback;
+  }
+  enter(element) {
+    if (this.predicate(element)) {
+      this.callback(element);
+      return this.returnOnTrue;
+    }
+    return this.returnOnFalse;
+  }
+}
+
+/**
+ * Executes the callback on this element and all descendants.
+ * @public
+ */
+exports.CallbackVisitor = CallbackVisitor;
+const traverse = (options, element) => {
+  let callback;
+  let predicate;
+  if ((0, _ramdaAdjunct.isFunction)(options)) {
+    callback = options;
+    predicate = _index.isElement;
+  } else {
+    callback = (0, _ramda.pathOr)(_ramdaAdjunct.noop, ['callback'], options);
+    predicate = (0, _ramda.pathOr)(_index.isElement, ['predicate'], options);
+  }
+  const visitor = new CallbackVisitor({
+    callback,
+    predicate
+  });
+
+  // @ts-ignore
+  (0, _visitor.visit)(element, visitor);
+};
+var _default = exports.default = traverse;

package/src/traversal/traverse.mjs

@@ -0,0 +1,53 @@
+import { pathOr } from 'ramda';
+import { isFunction, noop } from 'ramda-adjunct';
+import { visit, PredicateVisitor } from "./visitor.mjs";
+import { isElement } from "../predicates/index.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+export class CallbackVisitor extends PredicateVisitor {
+  callback;
+  constructor({
+    callback = noop,
+    ...rest
+  } = {}) {
+    super({
+      ...rest
+    });
+    this.callback = callback;
+  }
+  enter(element) {
+    if (this.predicate(element)) {
+      this.callback(element);
+      return this.returnOnTrue;
+    }
+    return this.returnOnFalse;
+  }
+}
+
+/**
+ * Executes the callback on this element and all descendants.
+ * @public
+ */
+const traverse = (options, element) => {
+  let callback;
+  let predicate;
+  if (isFunction(options)) {
+    callback = options;
+    predicate = isElement;
+  } else {
+    callback = pathOr(noop, ['callback'], options);
+    predicate = pathOr(isElement, ['predicate'], options);
+  }
+  const visitor = new CallbackVisitor({
+    callback,
+    predicate
+  });
+
+  // @ts-ignore
+  visit(element, visitor);
+};
+export default traverse;

package/src/traversal/visitor.cjs

@@ -0,0 +1,123 @@
+"use strict";
+
+exports.__esModule = true;
+exports.visit = exports.keyMapDefault = exports.isNode = exports.getNodeType = exports.cloneNode = exports.PredicateVisitor = void 0;
+var _ramda = require("ramda");
+var _ramdaAdjunct = require("ramda-adjunct");
+var _apidomAst = require("@speclynx/apidom-ast");
+exports.BREAK = _apidomAst.BREAK;
+exports.mergeAllVisitors = _apidomAst.mergeAllVisitors;
+var _index = require("../predicates/index.cjs");
+var _index2 = require("../clone/index.cjs");
+/**
+ * @public
+ */
+const getNodeType = element => {
+  /*
+   * We're translating every possible higher element type to primitive minim type here.
+   * We're using polymorphism to recognize any higher element type as ObjectElement or ArrayElement.
+   * Using polymorphism allows us to assume any namespace.
+   *
+   * There is a problem with naming visitor methods described here: https://github.com/babel/babel/discussions/12874
+   */
+  return (0, _index.isObjectElement)(element) ? 'ObjectElement' : (0, _index.isArrayElement)(element) ? 'ArrayElement' : (0, _index.isMemberElement)(element) ? 'MemberElement' : (0, _index.isStringElement)(element) ? 'StringElement' : (0, _index.isBooleanElement)(element) ? 'BooleanElement' : (0, _index.isNumberElement)(element) ? 'NumberElement' : (0, _index.isNullElement)(element) ? 'NullElement' : (0, _index.isLinkElement)(element) ? 'LinkElement' : (0, _index.isRefElement)(element) ? 'RefElement' : undefined;
+};
+
+/**
+ * @public
+ */
+exports.getNodeType = getNodeType;
+const cloneNode = node => {
+  if ((0, _index.isElement)(node)) {
+    return (0, _index2.cloneShallow)(node);
+  }
+  return (0, _apidomAst.cloneNode)(node);
+};
+
+// isNode :: Node -> Boolean
+exports.cloneNode = cloneNode;
+const isNode = exports.isNode = (0, _ramda.pipe)(getNodeType, _ramdaAdjunct.isString);
+
+/**
+ * @public
+ */
+const keyMapDefault = exports.keyMapDefault = {
+  ObjectElement: ['content'],
+  ArrayElement: ['content'],
+  MemberElement: ['key', 'value'],
+  StringElement: [],
+  BooleanElement: [],
+  NumberElement: [],
+  NullElement: [],
+  RefElement: [],
+  LinkElement: [],
+  Annotation: [],
+  Comment: [],
+  ParseResultElement: ['content'],
+  SourceMap: ['content']
+};
+class PredicateVisitor {
+  result;
+  predicate;
+  returnOnTrue;
+  returnOnFalse;
+  constructor({
+    predicate = _ramda.F,
+    returnOnTrue,
+    returnOnFalse
+  } = {}) {
+    this.result = [];
+    this.predicate = predicate;
+    this.returnOnTrue = returnOnTrue;
+    this.returnOnFalse = returnOnFalse;
+  }
+  enter(element) {
+    if (this.predicate(element)) {
+      this.result.push(element);
+      return this.returnOnTrue;
+    }
+    return this.returnOnFalse;
+  }
+}
+
+/**
+ * @public
+ */
+exports.PredicateVisitor = PredicateVisitor;
+const visit = (root,
+// @ts-ignore
+visitor, {
+  keyMap = keyMapDefault,
+  ...rest
+} = {}) => {
+  // @ts-ignore
+  return (0, _apidomAst.visit)(root, visitor, {
+    // @ts-ignore
+    keyMap,
+    // @ts-ignore
+    nodeTypeGetter: getNodeType,
+    nodePredicate: isNode,
+    nodeCloneFn: cloneNode,
+    ...rest
+  });
+};
+
+// @ts-ignore
+exports.visit = visit;
+visit[Symbol.for('nodejs.util.promisify.custom')] = async (root,
+// @ts-ignore
+visitor, {
+  keyMap = keyMapDefault,
+  ...rest
+} = {}) => {
+  // @ts-ignore
+  return _apidomAst.visit[Symbol.for('nodejs.util.promisify.custom')](root, visitor, {
+    // @ts-ignore
+    keyMap,
+    // @ts-ignore
+    nodeTypeGetter: getNodeType,
+    nodePredicate: isNode,
+    nodeCloneFn: cloneNode,
+    ...rest
+  });
+};

package/src/traversal/visitor.mjs

@@ -0,0 +1,115 @@
+import { F as stubFalse, pipe } from 'ramda';
+import { isString } from 'ramda-adjunct';
+import { visit as astVisit, BREAK, mergeAllVisitors, cloneNode as cloneNodeDefault } from '@speclynx/apidom-ast';
+import { isElement, isMemberElement, isArrayElement, isStringElement, isBooleanElement, isLinkElement, isRefElement, isObjectElement, isNullElement, isNumberElement } from "../predicates/index.mjs";
+import { cloneShallow } from "../clone/index.mjs";
+export { BREAK, mergeAllVisitors };
+
+/**
+ * @public
+ */
+export const getNodeType = element => {
+  /*
+   * We're translating every possible higher element type to primitive minim type here.
+   * We're using polymorphism to recognize any higher element type as ObjectElement or ArrayElement.
+   * Using polymorphism allows us to assume any namespace.
+   *
+   * There is a problem with naming visitor methods described here: https://github.com/babel/babel/discussions/12874
+   */
+  return isObjectElement(element) ? 'ObjectElement' : isArrayElement(element) ? 'ArrayElement' : isMemberElement(element) ? 'MemberElement' : isStringElement(element) ? 'StringElement' : isBooleanElement(element) ? 'BooleanElement' : isNumberElement(element) ? 'NumberElement' : isNullElement(element) ? 'NullElement' : isLinkElement(element) ? 'LinkElement' : isRefElement(element) ? 'RefElement' : undefined;
+};
+
+/**
+ * @public
+ */
+export const cloneNode = node => {
+  if (isElement(node)) {
+    return cloneShallow(node);
+  }
+  return cloneNodeDefault(node);
+};
+
+// isNode :: Node -> Boolean
+export const isNode = pipe(getNodeType, isString);
+
+/**
+ * @public
+ */
+export const keyMapDefault = {
+  ObjectElement: ['content'],
+  ArrayElement: ['content'],
+  MemberElement: ['key', 'value'],
+  StringElement: [],
+  BooleanElement: [],
+  NumberElement: [],
+  NullElement: [],
+  RefElement: [],
+  LinkElement: [],
+  Annotation: [],
+  Comment: [],
+  ParseResultElement: ['content'],
+  SourceMap: ['content']
+};
+export class PredicateVisitor {
+  result;
+  predicate;
+  returnOnTrue;
+  returnOnFalse;
+  constructor({
+    predicate = stubFalse,
+    returnOnTrue,
+    returnOnFalse
+  } = {}) {
+    this.result = [];
+    this.predicate = predicate;
+    this.returnOnTrue = returnOnTrue;
+    this.returnOnFalse = returnOnFalse;
+  }
+  enter(element) {
+    if (this.predicate(element)) {
+      this.result.push(element);
+      return this.returnOnTrue;
+    }
+    return this.returnOnFalse;
+  }
+}
+
+/**
+ * @public
+ */
+export const visit = (root,
+// @ts-ignore
+visitor, {
+  keyMap = keyMapDefault,
+  ...rest
+} = {}) => {
+  // @ts-ignore
+  return astVisit(root, visitor, {
+    // @ts-ignore
+    keyMap,
+    // @ts-ignore
+    nodeTypeGetter: getNodeType,
+    nodePredicate: isNode,
+    nodeCloneFn: cloneNode,
+    ...rest
+  });
+};
+
+// @ts-ignore
+visit[Symbol.for('nodejs.util.promisify.custom')] = async (root,
+// @ts-ignore
+visitor, {
+  keyMap = keyMapDefault,
+  ...rest
+} = {}) => {
+  // @ts-ignore
+  return astVisit[Symbol.for('nodejs.util.promisify.custom')](root, visitor, {
+    // @ts-ignore
+    keyMap,
+    // @ts-ignore
+    nodeTypeGetter: getNodeType,
+    nodePredicate: isNode,
+    nodeCloneFn: cloneNode,
+    ...rest
+  });
+};

package/src/util.cjs

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports.dereference = void 0;
+var _ramda = require("ramda");
+var _ramdaAdjunct = require("ramda-adjunct");
+/**
+ * This dereference algorithm is used exclusively for dereferencing specification objects.
+ * It doesn't handle circular references of external references and works on objects only (not arrays).
+ * @public
+ */
+
+const dereference = (object, root) => {
+  const rootObject = (0, _ramda.defaultTo)(object, root);
+  return (0, _ramda.mapObjIndexed)(val => {
+    if ((0, _ramdaAdjunct.isPlainObject)(val) && (0, _ramda.has)('$ref', val) && (0, _ramda.propSatisfies)(_ramdaAdjunct.isString, '$ref', val)) {
+      const $ref = (0, _ramda.path)(['$ref'], val);
+      // @ts-ignore
+      const pointer = (0, _ramdaAdjunct.trimCharsStart)('#/', $ref);
+      return (0, _ramda.path)(pointer.split('/'), rootObject);
+    }
+    if ((0, _ramdaAdjunct.isPlainObject)(val)) {
+      return dereference(val, rootObject);
+    }
+    return val;
+  }, object);
+};
+exports.dereference = dereference;

package/src/util.mjs

@@ -0,0 +1,24 @@
+import { defaultTo, has, mapObjIndexed, path, propSatisfies } from 'ramda';
+import { isPlainObject, isString, trimCharsStart } from 'ramda-adjunct';
+
+/**
+ * This dereference algorithm is used exclusively for dereferencing specification objects.
+ * It doesn't handle circular references of external references and works on objects only (not arrays).
+ * @public
+ */
+
+export const dereference = (object, root) => {
+  const rootObject = defaultTo(object, root);
+  return mapObjIndexed(val => {
+    if (isPlainObject(val) && has('$ref', val) && propSatisfies(isString, '$ref', val)) {
+      const $ref = path(['$ref'], val);
+      // @ts-ignore
+      const pointer = trimCharsStart('#/', $ref);
+      return path(pointer.split('/'), rootObject);
+    }
+    if (isPlainObject(val)) {
+      return dereference(val, rootObject);
+    }
+    return val;
+  }, object);
+};