@speclynx/apidom-core 1.12.1

package/src/predicates/helpers.mjs

@@ -0,0 +1,77 @@
+import { ArrayElement } from 'minim';
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+export const hasMethod = (name, element) => {
+  return typeof element === 'object' && element !== null && name in element && typeof element[name] === 'function';
+};
+
+/**
+ * @public
+ */
+export const hasBasicElementProps = element => typeof element === 'object' && element != null && '_storedElement' in element && typeof element._storedElement === 'string' && '_content' in element;
+
+/**
+ * @public
+ */
+export const primitiveEq = (val, element) => {
+  if (typeof element === 'object' && element !== null && 'primitive' in element) {
+    return typeof element.primitive === 'function' && element.primitive() === val;
+  }
+  return false;
+};
+
+/**
+ * @public
+ */
+export const hasClass = (cls, element) => {
+  return typeof element === 'object' && element !== null && 'classes' in element && (Array.isArray(element.classes) || element.classes instanceof ArrayElement) && element.classes.includes(cls);
+};
+
+/**
+ * @public
+ */
+export const isElementType = (name, element) => typeof element === 'object' && element !== null && 'element' in element && element.element === name;
+
+/**
+ * @public
+ */
+const createPredicate = predicateCreator => {
+  return predicateCreator({
+    hasMethod,
+    hasBasicElementProps,
+    primitiveEq,
+    isElementType,
+    hasClass
+  });
+};
+export default createPredicate;

package/src/predicates/index.cjs

@@ -0,0 +1,208 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.isStringElement = exports.isSourceMapElement = exports.isRefElement = exports.isPrimitiveElement = exports.isParseResultElement = exports.isObjectElement = exports.isNumberElement = exports.isNullElement = exports.isMemberElement = exports.isLinkElement = exports.isElement = exports.isCommentElement = exports.isBooleanElement = exports.isArrayElement = exports.isAnnotationElement = exports.includesSymbols = exports.includesClasses = exports.hasElementSourceMap = void 0;
+var _minim = require("minim");
+var _ramda = require("ramda");
+var _ramdaAdjunct = require("ramda-adjunct");
+var _Annotation = _interopRequireDefault(require("../elements/Annotation.cjs"));
+var _Comment = _interopRequireDefault(require("../elements/Comment.cjs"));
+var _ParseResult = _interopRequireDefault(require("../elements/ParseResult.cjs"));
+var _SourceMap = _interopRequireDefault(require("../elements/SourceMap.cjs"));
+var _helpers = _interopRequireWildcard(require("./helpers.cjs"));
+/**
+ * @public
+ */
+const isElement = exports.isElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof _minim.Element || hasBasicElementProps(element) && primitiveEq(undefined, element);
+});
+
+/**
+ * @public
+ */
+const isStringElement = exports.isStringElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof _minim.StringElement || hasBasicElementProps(element) && primitiveEq('string', element);
+});
+
+/**
+ * @public
+ */
+const isNumberElement = exports.isNumberElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof _minim.NumberElement || hasBasicElementProps(element) && primitiveEq('number', element);
+});
+
+/**
+ * @public
+ */
+const isNullElement = exports.isNullElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof _minim.NullElement || hasBasicElementProps(element) && primitiveEq('null', element);
+});
+
+/**
+ * @public
+ */
+const isBooleanElement = exports.isBooleanElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof _minim.BooleanElement || hasBasicElementProps(element) && primitiveEq('boolean', element);
+});
+
+/**
+ * @public
+ */
+const isObjectElement = exports.isObjectElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  primitiveEq,
+  hasMethod
+}) => {
+  return element => element instanceof _minim.ObjectElement || hasBasicElementProps(element) && primitiveEq('object', element) && hasMethod('keys', element) && hasMethod('values', element) && hasMethod('items', element);
+});
+
+/**
+ * @public
+ */
+const isArrayElement = exports.isArrayElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  primitiveEq,
+  hasMethod
+}) => {
+  return element => element instanceof _minim.ArrayElement && !(element instanceof _minim.ObjectElement) || hasBasicElementProps(element) && primitiveEq('array', element) && hasMethod('push', element) && hasMethod('unshift', element) && hasMethod('map', element) && hasMethod('reduce', element);
+});
+
+/**
+ * @public
+ */
+const isMemberElement = exports.isMemberElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof _minim.MemberElement || hasBasicElementProps(element) && isElementType('member', element) && primitiveEq(undefined, element);
+});
+
+/**
+ * @public
+ */
+const isLinkElement = exports.isLinkElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof _minim.LinkElement || hasBasicElementProps(element) && isElementType('link', element) && primitiveEq(undefined, element);
+});
+
+/**
+ * @public
+ */
+const isRefElement = exports.isRefElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof _minim.RefElement || hasBasicElementProps(element) && isElementType('ref', element) && primitiveEq(undefined, element);
+});
+
+/**
+ * @public
+ */
+const isAnnotationElement = exports.isAnnotationElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof _Annotation.default || hasBasicElementProps(element) && isElementType('annotation', element) && primitiveEq('array', element);
+});
+
+/**
+ * @public
+ */
+const isCommentElement = exports.isCommentElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof _Comment.default || hasBasicElementProps(element) && isElementType('comment', element) && primitiveEq('string', element);
+});
+
+/**
+ * @public
+ */
+const isParseResultElement = exports.isParseResultElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof _ParseResult.default || hasBasicElementProps(element) && isElementType('parseResult', element) && primitiveEq('array', element);
+});
+
+/**
+ * @public
+ */
+const isSourceMapElement = exports.isSourceMapElement = (0, _helpers.default)(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof _SourceMap.default || hasBasicElementProps(element) && isElementType('sourceMap', element) && primitiveEq('array', element);
+});
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+const isPrimitiveElement = element => {
+  return (0, _helpers.isElementType)('object', element) || (0, _helpers.isElementType)('array', element) || (0, _helpers.isElementType)('boolean', element) || (0, _helpers.isElementType)('number', element) || (0, _helpers.isElementType)('string', element) || (0, _helpers.isElementType)('null', element) || (0, _helpers.isElementType)('member', element);
+};
+
+/**
+ * @public
+ */
+exports.isPrimitiveElement = isPrimitiveElement;
+const hasElementSourceMap = element => {
+  return isSourceMapElement(element.meta.get('sourceMap'));
+};
+
+/**
+ * @public
+ */
+exports.hasElementSourceMap = hasElementSourceMap;
+const includesSymbols = (symbols, element) => {
+  if (symbols.length === 0) {
+    return true;
+  }
+  const elementSymbols = element.attributes.get('symbols');
+  if (!isArrayElement(elementSymbols)) {
+    return false;
+  }
+  return (0, _ramda.all)((0, _ramdaAdjunct.included)(elementSymbols.toValue()), symbols);
+};
+
+/**
+ * @public
+ */
+exports.includesSymbols = includesSymbols;
+const includesClasses = (classes, element) => {
+  if (classes.length === 0) {
+    return true;
+  }
+  return (0, _ramda.all)((0, _ramdaAdjunct.included)(element.classes.toValue()), classes);
+};
+exports.includesClasses = includesClasses;

package/src/predicates/index.mjs

@@ -0,0 +1,198 @@
+import { Element, StringElement, NumberElement, NullElement, BooleanElement, ArrayElement, ObjectElement, MemberElement, LinkElement, RefElement } from 'minim';
+import { all } from 'ramda';
+import { included } from 'ramda-adjunct';
+import AnnotationElement from "../elements/Annotation.mjs";
+import CommentElement from "../elements/Comment.mjs";
+import ParserResultElement from "../elements/ParseResult.mjs";
+import SourceMapElement from "../elements/SourceMap.mjs";
+import createPredicate, { isElementType as isElementTypeHelper } from "./helpers.mjs";
+/**
+ * @public
+ */
+export const isElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof Element || hasBasicElementProps(element) && primitiveEq(undefined, element);
+});
+
+/**
+ * @public
+ */
+export const isStringElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof StringElement || hasBasicElementProps(element) && primitiveEq('string', element);
+});
+
+/**
+ * @public
+ */
+export const isNumberElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof NumberElement || hasBasicElementProps(element) && primitiveEq('number', element);
+});
+
+/**
+ * @public
+ */
+export const isNullElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof NullElement || hasBasicElementProps(element) && primitiveEq('null', element);
+});
+
+/**
+ * @public
+ */
+export const isBooleanElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq
+}) => {
+  return element => element instanceof BooleanElement || hasBasicElementProps(element) && primitiveEq('boolean', element);
+});
+
+/**
+ * @public
+ */
+export const isObjectElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq,
+  hasMethod
+}) => {
+  return element => element instanceof ObjectElement || hasBasicElementProps(element) && primitiveEq('object', element) && hasMethod('keys', element) && hasMethod('values', element) && hasMethod('items', element);
+});
+
+/**
+ * @public
+ */
+export const isArrayElement = createPredicate(({
+  hasBasicElementProps,
+  primitiveEq,
+  hasMethod
+}) => {
+  return element => element instanceof ArrayElement && !(element instanceof ObjectElement) || hasBasicElementProps(element) && primitiveEq('array', element) && hasMethod('push', element) && hasMethod('unshift', element) && hasMethod('map', element) && hasMethod('reduce', element);
+});
+
+/**
+ * @public
+ */
+export const isMemberElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof MemberElement || hasBasicElementProps(element) && isElementType('member', element) && primitiveEq(undefined, element);
+});
+
+/**
+ * @public
+ */
+export const isLinkElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof LinkElement || hasBasicElementProps(element) && isElementType('link', element) && primitiveEq(undefined, element);
+});
+
+/**
+ * @public
+ */
+export const isRefElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof RefElement || hasBasicElementProps(element) && isElementType('ref', element) && primitiveEq(undefined, element);
+});
+
+/**
+ * @public
+ */
+export const isAnnotationElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof AnnotationElement || hasBasicElementProps(element) && isElementType('annotation', element) && primitiveEq('array', element);
+});
+
+/**
+ * @public
+ */
+export const isCommentElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof CommentElement || hasBasicElementProps(element) && isElementType('comment', element) && primitiveEq('string', element);
+});
+
+/**
+ * @public
+ */
+export const isParseResultElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof ParserResultElement || hasBasicElementProps(element) && isElementType('parseResult', element) && primitiveEq('array', element);
+});
+
+/**
+ * @public
+ */
+export const isSourceMapElement = createPredicate(({
+  hasBasicElementProps,
+  isElementType,
+  primitiveEq
+}) => {
+  return element => element instanceof SourceMapElement || hasBasicElementProps(element) && isElementType('sourceMap', element) && primitiveEq('array', element);
+});
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+export const isPrimitiveElement = element => {
+  return isElementTypeHelper('object', element) || isElementTypeHelper('array', element) || isElementTypeHelper('boolean', element) || isElementTypeHelper('number', element) || isElementTypeHelper('string', element) || isElementTypeHelper('null', element) || isElementTypeHelper('member', element);
+};
+
+/**
+ * @public
+ */
+export const hasElementSourceMap = element => {
+  return isSourceMapElement(element.meta.get('sourceMap'));
+};
+
+/**
+ * @public
+ */
+export const includesSymbols = (symbols, element) => {
+  if (symbols.length === 0) {
+    return true;
+  }
+  const elementSymbols = element.attributes.get('symbols');
+  if (!isArrayElement(elementSymbols)) {
+    return false;
+  }
+  return all(included(elementSymbols.toValue()), symbols);
+};
+
+/**
+ * @public
+ */
+export const includesClasses = (classes, element) => {
+  if (classes.length === 0) {
+    return true;
+  }
+  return all(included(element.classes.toValue()), classes);
+};

package/src/refractor/index.cjs

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = exports.createRefractor = void 0;
+var _index = require("./plugins/dispatcher/index.cjs");
+var _visitor = require("../traversal/visitor.cjs");
+var _index2 = require("../clone/index.cjs");
+var _index3 = require("../predicates/index.cjs");
+var _toolbox = _interopRequireDefault(require("./toolbox.cjs"));
+const refract = (value, {
+  Type,
+  plugins = []
+}) => {
+  /**
+   * This is where values gets refracted into generic ApiDOM.
+   * We don't allow consumers to hook into this translation.
+   * Though we allow consumers to define their onw plugins on already transformed ApiDOM.
+   */
+  const element = new Type(value);
+  if ((0, _index3.isElement)(value)) {
+    if (value.meta.length > 0) {
+      element.meta = (0, _index2.cloneDeep)(value.meta);
+    }
+    if (value.attributes.length > 0) {
+      element.attributes = (0, _index2.cloneDeep)(value.attributes);
+    }
+  }
+
+  /**
+   * Run plugins only when necessary.
+   * Running plugins visitors means extra single traversal === performance hit.
+   */
+  return (0, _index.dispatchPluginsSync)(element, plugins, {
+    toolboxCreator: _toolbox.default,
+    visitorOptions: {
+      nodeTypeGetter: _visitor.getNodeType
+    }
+  });
+};
+const createRefractor = Type => (value, options = {}) => refract(value, {
+  ...options,
+  Type
+});
+exports.createRefractor = createRefractor;
+var _default = exports.default = refract;

package/src/refractor/index.mjs

@@ -0,0 +1,40 @@
+import { dispatchPluginsSync } from "./plugins/dispatcher/index.mjs";
+import { getNodeType } from "../traversal/visitor.mjs";
+import { cloneDeep } from "../clone/index.mjs";
+import { isElement } from "../predicates/index.mjs";
+import createToolbox from "./toolbox.mjs";
+const refract = (value, {
+  Type,
+  plugins = []
+}) => {
+  /**
+   * This is where values gets refracted into generic ApiDOM.
+   * We don't allow consumers to hook into this translation.
+   * Though we allow consumers to define their onw plugins on already transformed ApiDOM.
+   */
+  const element = new Type(value);
+  if (isElement(value)) {
+    if (value.meta.length > 0) {
+      element.meta = cloneDeep(value.meta);
+    }
+    if (value.attributes.length > 0) {
+      element.attributes = cloneDeep(value.attributes);
+    }
+  }
+
+  /**
+   * Run plugins only when necessary.
+   * Running plugins visitors means extra single traversal === performance hit.
+   */
+  return dispatchPluginsSync(element, plugins, {
+    toolboxCreator: createToolbox,
+    visitorOptions: {
+      nodeTypeGetter: getNodeType
+    }
+  });
+};
+export const createRefractor = Type => (value, options = {}) => refract(value, {
+  ...options,
+  Type
+});
+export default refract;

package/src/refractor/plugins/dispatcher/index.cjs

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.dispatchPluginsSync = exports.dispatchPluginsAsync = void 0;
+var _ramda = require("ramda");
+var _ramdaAdjunct = require("ramda-adjunct");
+var _toolbox = _interopRequireDefault(require("../../toolbox.cjs"));
+var _visitor = require("../../../traversal/visitor.cjs");
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+const defaultDispatchPluginsOptions = {
+  toolboxCreator: _toolbox.default,
+  visitorOptions: {
+    nodeTypeGetter: _visitor.getNodeType,
+    exposeEdits: true
+  }
+};
+
+/**
+ * @public
+ */
+const dispatchPluginsSync = (element, plugins, options = {}) => {
+  if (plugins.length === 0) return element;
+  const mergedOptions = (0, _ramda.mergeDeepRight)(defaultDispatchPluginsOptions, options);
+  const {
+    toolboxCreator,
+    visitorOptions
+  } = mergedOptions;
+  const toolbox = toolboxCreator();
+  const pluginsSpecs = plugins.map(plugin => plugin(toolbox));
+  const mergedPluginsVisitor = (0, _visitor.mergeAllVisitors)(pluginsSpecs.map((0, _ramda.propOr)({}, 'visitor')), {
+    ...visitorOptions
+  });
+  pluginsSpecs.forEach((0, _ramdaAdjunct.invokeArgs)(['pre'], []));
+  const newElement = (0, _visitor.visit)(element, mergedPluginsVisitor, visitorOptions);
+  pluginsSpecs.forEach((0, _ramdaAdjunct.invokeArgs)(['post'], []));
+  return newElement;
+};
+exports.dispatchPluginsSync = dispatchPluginsSync;
+const dispatchPluginsAsync = async (element, plugins, options = {}) => {
+  if (plugins.length === 0) return element;
+  const mergedOptions = (0, _ramda.mergeDeepRight)(defaultDispatchPluginsOptions, options);
+  const {
+    toolboxCreator,
+    visitorOptions
+  } = mergedOptions;
+  const toolbox = toolboxCreator();
+  const pluginsSpecs = plugins.map(plugin => plugin(toolbox));
+  const mergeAllVisitorsAsync = _visitor.mergeAllVisitors[Symbol.for('nodejs.util.promisify.custom')];
+  const visitAsync = _visitor.visit[Symbol.for('nodejs.util.promisify.custom')];
+  const mergedPluginsVisitor = mergeAllVisitorsAsync(pluginsSpecs.map((0, _ramda.propOr)({}, 'visitor')), {
+    ...visitorOptions
+  });
+  await Promise.allSettled(pluginsSpecs.map((0, _ramdaAdjunct.invokeArgs)(['pre'], [])));
+  const newElement = await visitAsync(element, mergedPluginsVisitor, visitorOptions);
+  await Promise.allSettled(pluginsSpecs.map((0, _ramdaAdjunct.invokeArgs)(['post'], [])));
+  return newElement;
+};
+exports.dispatchPluginsAsync = dispatchPluginsAsync;
+dispatchPluginsSync[Symbol.for('nodejs.util.promisify.custom')] = dispatchPluginsAsync;

package/src/refractor/plugins/dispatcher/index.mjs

@@ -0,0 +1,61 @@
+import { mergeDeepRight, propOr } from 'ramda';
+import { invokeArgs } from 'ramda-adjunct';
+import createToolbox from "../../toolbox.mjs";
+import { getNodeType, mergeAllVisitors, visit } from "../../../traversal/visitor.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+const defaultDispatchPluginsOptions = {
+  toolboxCreator: createToolbox,
+  visitorOptions: {
+    nodeTypeGetter: getNodeType,
+    exposeEdits: true
+  }
+};
+
+/**
+ * @public
+ */
+export const dispatchPluginsSync = (element, plugins, options = {}) => {
+  if (plugins.length === 0) return element;
+  const mergedOptions = mergeDeepRight(defaultDispatchPluginsOptions, options);
+  const {
+    toolboxCreator,
+    visitorOptions
+  } = mergedOptions;
+  const toolbox = toolboxCreator();
+  const pluginsSpecs = plugins.map(plugin => plugin(toolbox));
+  const mergedPluginsVisitor = mergeAllVisitors(pluginsSpecs.map(propOr({}, 'visitor')), {
+    ...visitorOptions
+  });
+  pluginsSpecs.forEach(invokeArgs(['pre'], []));
+  const newElement = visit(element, mergedPluginsVisitor, visitorOptions);
+  pluginsSpecs.forEach(invokeArgs(['post'], []));
+  return newElement;
+};
+export const dispatchPluginsAsync = async (element, plugins, options = {}) => {
+  if (plugins.length === 0) return element;
+  const mergedOptions = mergeDeepRight(defaultDispatchPluginsOptions, options);
+  const {
+    toolboxCreator,
+    visitorOptions
+  } = mergedOptions;
+  const toolbox = toolboxCreator();
+  const pluginsSpecs = plugins.map(plugin => plugin(toolbox));
+  const mergeAllVisitorsAsync = mergeAllVisitors[Symbol.for('nodejs.util.promisify.custom')];
+  const visitAsync = visit[Symbol.for('nodejs.util.promisify.custom')];
+  const mergedPluginsVisitor = mergeAllVisitorsAsync(pluginsSpecs.map(propOr({}, 'visitor')), {
+    ...visitorOptions
+  });
+  await Promise.allSettled(pluginsSpecs.map(invokeArgs(['pre'], [])));
+  const newElement = await visitAsync(element, mergedPluginsVisitor, visitorOptions);
+  await Promise.allSettled(pluginsSpecs.map(invokeArgs(['post'], [])));
+  return newElement;
+};
+dispatchPluginsSync[Symbol.for('nodejs.util.promisify.custom')] = dispatchPluginsAsync;