@swagger-api/apidom-core 0.68.1

package/es/transcluder/Transcluder.js

@@ -0,0 +1,104 @@
+import stampit from 'stampit';
+import { isUndefined } from 'ramda-adjunct';
+import { isObjectElement, isArrayElement, isMemberElement } from "../predicates/index.js";
+const computeEdges = (element, edges = new WeakMap()) => {
+  if (isMemberElement(element)) {
+    // @ts-ignore
+    edges.set(element.key, element);
+    // @ts-ignore
+    computeEdges(element.key, edges);
+    // @ts-ignore
+    edges.set(element.value, element);
+    // @ts-ignore
+    computeEdges(element.value, edges);
+  } else {
+    element.children.forEach(childElement => {
+      edges.set(childElement, element);
+      computeEdges(childElement, edges);
+    });
+  }
+  return edges;
+};
+const transcludeChildOfMemberElement = (search, replace, edges) => {
+  const memberElement = edges.get(search);
+  if (!isMemberElement(memberElement)) {
+    return;
+  }
+  if (memberElement.key === search) {
+    memberElement.key = replace;
+    edges.delete(search);
+    edges.set(replace, memberElement);
+  }
+  if (memberElement.value === search) {
+    memberElement.value = replace;
+    edges.delete(search);
+    edges.set(replace, memberElement);
+  }
+};
+const transcludeChildOfObjectElement = (search, replace, edges) => {
+  const objectElement = edges.get(search);
+  if (!isObjectElement(objectElement)) {
+    return;
+  }
+  objectElement.content = objectElement.map((value, key, member) => {
+    if (member === search) {
+      edges.delete(search);
+      edges.set(replace, objectElement);
+      return replace;
+    }
+    return member;
+  });
+};
+const transcludeChildOfArrayElement = (search, replace, edges) => {
+  const arrayElement = edges.get(search);
+  if (!isArrayElement(arrayElement)) {
+    return;
+  }
+  arrayElement.content = arrayElement.map(element => {
+    if (element === search) {
+      edges.delete(search);
+      edges.set(replace, arrayElement);
+      return replace;
+    }
+    return element;
+  });
+};
+
+/**
+ * This is a mutating stamp. If you don't want your Element to be mutated,
+ * clone in before passing it to initializer of this stamp.
+ */
+
+const Transcluder = stampit.init(function TranscluderConstructor({
+  element
+}) {
+  let edges;
+  this.transclude = function transclude(search, replace) {
+    var _edges;
+    // shortcut 1. - replacing entire ApiDOM tree
+    if (search === element) return replace;
+    // shortcut 2. - replacing nothing
+    if (search === replace) return element;
+    edges = (_edges = edges) !== null && _edges !== void 0 ? _edges : computeEdges(element);
+    const parent = edges.get(search);
+    if (isUndefined(parent)) {
+      return undefined;
+    }
+
+    /**
+     * This predicate must be first because ObjectElement extends ArrayElement.
+     * isArrayElement returns true for ObjectElements.
+     * (classical problems with polymorphism)
+     */
+    if (isObjectElement(parent)) {
+      // @ts-ignore
+      transcludeChildOfObjectElement(search, replace, edges);
+    } else if (isArrayElement(parent)) {
+      transcludeChildOfArrayElement(search, replace, edges);
+    } else if (isMemberElement(parent)) {
+      transcludeChildOfMemberElement(search, replace, edges);
+    }
+    return element;
+  };
+});
+export default Transcluder;

package/es/transcluder/index.js

@@ -0,0 +1,12 @@
+import Transcluder from "./Transcluder.js";
+/**
+ * This is a mutating function. If you don't want your Element to be mutated,
+ * clone in before passing it to this function.
+ */
+export const transclude = (search, replace, element) => {
+  const transcluder = Transcluder({
+    element
+  });
+  return transcluder.transclude(search, replace);
+};
+export default Transcluder;

package/es/traversal/filter.js

@@ -0,0 +1,14 @@
+import { curry } from 'ramda';
+import { ArraySlice } from 'minim';
+import { PredicateVisitor, visit } from "./visitor.js"; // finds all elements matching the predicate
+// filter :: Pred -> Element -> ArraySlice
+const filter = curry((predicate, element) => {
+  const visitor = PredicateVisitor({
+    predicate
+  });
+
+  // @ts-ignore
+  visit(element, visitor);
+  return new ArraySlice(visitor.result);
+});
+export default filter;

package/es/traversal/find.js

@@ -0,0 +1,14 @@
+import { curry, pathOr } from 'ramda';
+import { PredicateVisitor, BREAK, visit } from "./visitor.js"; // find first element that satisfies the provided predicate
+// find :: Pred -> Element -> Element | Undefined
+const find = curry((predicate, element) => {
+  const visitor = PredicateVisitor({
+    predicate,
+    returnOnTrue: BREAK
+  });
+
+  // @ts-ignore
+  visit(element, visitor);
+  return pathOr(undefined, [0], visitor.result);
+});
+export default find;

package/es/traversal/findAtOffset.js

@@ -0,0 +1,65 @@
+import stampit from 'stampit';
+import { curry, last, pathOr } from 'ramda';
+import { isNumber } from 'ramda-adjunct';
+import { hasElementSourceMap } from "../predicates/index.js";
+import { visit } from "./visitor.js";
+const Visitor = stampit({
+  props: {
+    result: [],
+    offset: 0,
+    includeRightBound: false
+  },
+  // @ts-ignore
+  init({
+    offset = this.offset,
+    includeRightBound = this.includeRightBound
+  }) {
+    this.result = [];
+    this.offset = offset;
+    this.includeRightBound = includeRightBound;
+  },
+  methods: {
+    enter(element) {
+      if (!hasElementSourceMap(element)) {
+        return undefined; // dive in
+      }
+
+      const sourceMapElement = element.getMetaProperty('sourceMap');
+      const charStart = sourceMapElement.positionStart.get(2).toValue();
+      const charEnd = sourceMapElement.positionEnd.get(2).toValue();
+      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
+    }
+  }
+});
+
+// Finds the most inner node at the given offset.
+// If includeRightBound is set, also finds nodes that end at the given offset.
+// findAtOffset :: Number -> Element -> Element | Undefined
+const findAtOffset = curry((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 = Visitor({
+    offset,
+    includeRightBound
+  });
+
+  // @ts-ignore
+  visit(element, visitor);
+
+  // @ts-ignore
+  return last(visitor.result);
+});
+export default findAtOffset;

package/es/traversal/index.js

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

package/es/traversal/parents.js

@@ -0,0 +1,40 @@
+import stampit from 'stampit';
+import { visit } from "./visitor.js";
+/* eslint-disable no-param-reassign */
+const Visitor = stampit({
+  props: {
+    parent: null,
+    parentEdges: null
+  },
+  init() {
+    this.parentEdges = new WeakMap();
+  },
+  methods: {
+    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);
+    }
+  }
+});
+
+/* eslint-enable */
+
+// computes upwards edges from every child to its parent
+// find :: Element -> WeakMap<Element, Element>
+const parents = element => {
+  const visitor = Visitor();
+  visit(element, visitor);
+  return visitor.parentEdges;
+};
+export default parents;

package/es/traversal/reject.js

@@ -0,0 +1,7 @@
+import { complement, curry } from 'ramda';
+import filter from "./filter.js"; // complement of filter
+// reject :: Pred -> Element -> ArraySlice
+const reject = curry((predicate, element) => {
+  return filter(complement(predicate))(element);
+});
+export default reject;

package/es/traversal/some.js

@@ -0,0 +1,8 @@
+import { curry } from 'ramda';
+import { isNotUndefined } from 'ramda-adjunct';
+import find from "./find.js"; // tests whether at least one element passes the predicate
+// some :: Pred -> Element -> Boolean
+const some = curry((predicate, element) => {
+  return isNotUndefined(find(predicate)(element));
+});
+export default some;

package/es/traversal/traverse.js

@@ -0,0 +1,47 @@
+import stampit from 'stampit';
+import { curry, pathOr } from 'ramda';
+import { isFunction, noop } from 'ramda-adjunct';
+import { visit, PredicateVisitor } from "./visitor.js";
+import { isElement } from "../predicates/index.js";
+export const CallbackVisitor = stampit(PredicateVisitor, {
+  props: {
+    callback: noop
+  },
+  // @ts-ignore
+  init({
+    callback = this.callback
+  } = {}) {
+    this.callback = callback;
+  },
+  methods: {
+    enter(element) {
+      if (this.predicate(element)) {
+        this.callback(element);
+        return this.returnOnTrue;
+      }
+      return this.returnOnFalse;
+    }
+  }
+});
+
+// executes the callback on this element and all descendants
+// traverse :: Callback | { predicate: Pred, callback: Callback } -> Element -> Undefined
+const traverse = curry((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 = CallbackVisitor({
+    callback,
+    predicate
+  });
+
+  // @ts-ignore
+  visit(element, visitor);
+});
+export default traverse;

package/es/traversal/visitor.js

@@ -0,0 +1,110 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+import _objectWithoutProperties from "@babel/runtime-corejs3/helpers/esm/objectWithoutProperties";
+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 stampit from 'stampit';
+import { curryN, F as stubFalse, pipe } from 'ramda';
+import { isString } from 'ramda-adjunct';
+import { visit as astVisit, BREAK, mergeAllVisitors } from '@swagger-api/apidom-ast';
+import { isMemberElement, isArrayElement, isStringElement, isBooleanElement, isLinkElement, isRefElement, isObjectElement, isNullElement, isNumberElement } from "../predicates/index.js";
+export { BREAK, mergeAllVisitors };
+
+// getNodeType :: Node -> String
+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
+   */
+  /* eslint-disable no-nested-ternary */
+  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;
+  /* eslint-enable */
+};
+
+// isNode :: Node -> Boolean
+export const isNode = curryN(1, pipe(getNodeType, isString));
+export const keyMapDefault = {
+  ObjectElement: ['content'],
+  ArrayElement: ['content'],
+  MemberElement: ['key', 'value'],
+  StringElement: [],
+  BooleanElement: [],
+  NumberElement: [],
+  NullElement: [],
+  RefElement: [],
+  LinkElement: [],
+  Annotation: [],
+  Comment: [],
+  ParseResultElement: ['content'],
+  SourceMap: ['content']
+};
+export const PredicateVisitor = stampit({
+  props: {
+    result: [],
+    predicate: stubFalse,
+    returnOnTrue: undefined,
+    returnOnFalse: undefined
+  },
+  init({
+    // @ts-ignore
+    predicate = this.predicate,
+    // @ts-ignore
+    returnOnTrue = this.returnOnTrue,
+    // @ts-ignore
+    returnOnFalse = this.returnOnFalse
+  } = {}) {
+    this.result = [];
+    this.predicate = predicate;
+    this.returnOnTrue = returnOnTrue;
+    this.returnOnFalse = returnOnFalse;
+  },
+  methods: {
+    enter(element) {
+      if (this.predicate(element)) {
+        this.result.push(element);
+        return this.returnOnTrue;
+      }
+      return this.returnOnFalse;
+    }
+  }
+});
+
+// @ts-ignore
+export const visit = (root,
+// @ts-ignore
+visitor, _ref = {}) => {
+  let {
+      keyMap = keyMapDefault
+    } = _ref,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  // @ts-ignore
+  return astVisit(root, visitor, _objectSpread({
+    // @ts-ignore
+    keyMap,
+    // @ts-ignore
+    nodeTypeGetter: getNodeType,
+    nodePredicate: isNode
+  }, rest));
+};
+
+// @ts-ignore
+visit[Symbol.for('nodejs.util.promisify.custom')] = async (root,
+// @ts-ignore
+visitor, _ref2 = {}) => {
+  let {
+      keyMap = keyMapDefault
+    } = _ref2,
+    rest = _objectWithoutProperties(_ref2, _excluded2);
+  // @ts-ignore
+  return astVisit[Symbol.for('nodejs.util.promisify.custom')](root, visitor, _objectSpread({
+    // @ts-ignore
+    keyMap,
+    // @ts-ignore
+    nodeTypeGetter: getNodeType,
+    nodePredicate: isNode
+  }, rest));
+};

package/es/util.js

@@ -0,0 +1,23 @@
+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).
+ */
+// eslint-disable-next-line import/prefer-default-export
+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);
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@swagger-api/apidom-core",
+  "version": "0.68.1",
+  "description": "Tools for manipulating ApiDOM structures.",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "type": "module",
+  "sideEffects": [
+    "./es/refractor/registration.js",
+    "./cjs/refractor/registration.cjs"
+  ],
+  "unpkg": "./dist/apidom-core.browser.min.js",
+  "main": "./cjs/index.cjs",
+  "exports": {
+    "types": "./types/dist.d.ts",
+    "import": "./es/index.js",
+    "require": "./cjs/index.cjs"
+  },
+  "types": "./types/dist.d.ts",
+  "scripts": {
+    "build": "npm run clean && run-p --max-parallel ${CPU_CORES:-2} typescript:declaration build:es build:cjs build:umd:browser",
+    "build:es": "cross-env BABEL_ENV=es babel src --out-dir es --extensions '.ts' --root-mode 'upward'",
+    "build:cjs": "cross-env BABEL_ENV=cjs babel src --out-dir cjs --extensions '.ts' --out-file-extension '.cjs' --root-mode 'upward'",
+    "build:umd:browser": "cross-env BABEL_ENV=browser BROWSERSLIST_ENV=production webpack --config config/webpack/browser.config.js --progress",
+    "lint": "eslint ./",
+    "lint:fix": "eslint ./ --fix",
+    "clean": "rimraf ./es ./cjs ./dist ./types",
+    "typescript:check-types": "tsc -p check-types.tsconfig.json --noEmit",
+    "typescript:declaration": "tsc -p declaration.tsconfig.json && rollup -c config/rollup/types.dist.js && copyfiles -u 2 ../@types/minim.d.ts ./types && node ../../scripts/file-prepend-bof.js './types/dist.d.ts' '/// <reference path=\"./minim.d.ts\" />'",
+    "test": "cross-env NODE_ENV=test BABEL_ENV=cjs mocha",
+    "test:update-snapshots": "cross-env UPDATE_SNAPSHOT=1 BABEL_ENV=cjs mocha",
+    "prepack": "copyfiles -u 3 ../../LICENSES/* LICENSES && copyfiles -u 2 ../../NOTICE",
+    "postpack": "rimraf NOTICE LICENSES"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/swagger-api/apidom.git"
+  },
+  "author": "Vladimír Gorej",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@babel/runtime-corejs3": "^7.20.7",
+    "@swagger-api/apidom-ast": "^0.68.0",
+    "@types/ramda": "=0.28.23",
+    "minim": "=0.23.8",
+    "ramda": "=0.28.0",
+    "ramda-adjunct": "=3.4.0",
+    "short-unique-id": "=4.4.4",
+    "stampit": "=4.3.2"
+  },
+  "files": [
+    "cjs/",
+    "dist/",
+    "es/",
+    "types/dist.d.ts",
+    "types/minim.d.ts",
+    "LICENSES",
+    "NOTICE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "gitHead": "d2bc706671f1b9a593b8f0c5bca8c501ad0e4cff"
+}