@speclynx/apidom-core 1.12.1

package/src/index.mjs

@@ -0,0 +1,50 @@
+export { dispatchPluginsSync as dispatchRefractorPlugins } from "./refractor/plugins/dispatcher/index.mjs";
+export { default as refractorPluginElementIdentity } from "./refractor/plugins/element-identity.mjs";
+export { default as refractorPluginSemanticElementIdentity } from "./refractor/plugins/semantic-element-identity.mjs";
+export { default as MediaTypes } from "./media-types.mjs";
+export { Element, MemberElement, KeyValuePair, ObjectSlice, ArraySlice, refract } from 'minim';
+export { default as namespace, Namespace, createNamespace } from "./namespace.mjs";
+export { ObjectElement, ArrayElement, BooleanElement, NullElement, NumberElement, StringElement, LinkElement, RefElement, AnnotationElement, CommentElement, ParseResultElement, SourceMapElement } from "./refractor/registration.mjs";
+export { isElement, isStringElement, isNumberElement, isNullElement, isBooleanElement, isArrayElement, isObjectElement, isMemberElement, isLinkElement, isRefElement, isAnnotationElement, isParseResultElement, isSourceMapElement, isPrimitiveElement, hasElementSourceMap, includesSymbols, includesClasses } from "./predicates/index.mjs";
+export { default as createPredicate } from "./predicates/helpers.mjs";
+export { filter, reject, find, findAtOffset, some, traverse, parents } from "./traversal/index.mjs";
+export { visit, BREAK, mergeAllVisitors, getNodeType, cloneNode, keyMapDefault as keyMap } from "./traversal/visitor.mjs";
+export { transclude, default as Transcluder } from "./transcluder/index.mjs";
+export { dereference } from "./util.mjs";
+export { cloneShallow, cloneDeep } from "./clone/index.mjs";
+export { default as CloneError } from "./clone/errors/CloneError.mjs";
+export { default as DeepCloneError } from "./clone/errors/DeepCloneError.mjs";
+export { default as ShallowCloneError } from "./clone/errors/ShallowCloneError.mjs";
+export { defaultIdentityManager, IdentityManager } from "./identity/index.mjs";
+export { default as ElementIdentityError } from "./identity/errors/ElementIdentityError.mjs";
+/**
+ * Transforms data to an Element from a particular namespace.
+ */
+export { default as from } from "./transformers/from.mjs";
+/**
+ * Transforms the ApiDOM into JavaScript POJO.
+ * This POJO would be the result of interpreting the ApiDOM
+ * into JavaScript structure.
+ */
+export { default as toValue } from "./transformers/serializers/value/index.mjs";
+/**
+ * Transforms the ApiDOM into JSON string.
+ */
+export { default as toJSON } from "./transformers/serializers/json.mjs";
+/**
+ * Transforms the ApiDOM into YAML string.
+ */
+export { default as toYAML } from "./transformers/serializers/yaml-1-2.mjs";
+/**
+ * Creates a refract representation of an Element.
+ * https://github.com/refractproject/refract-spec
+ */
+export { default as dehydrate } from "./transformers/dehydrate.mjs";
+/**
+ * Create a refracted string representation of an Element.
+ */
+export { default as toString } from "./transformers/to-string.mjs";
+export { default as sexprs } from "./transformers/sexprs.mjs";
+export { default as deepmerge } from "./merge/deepmerge.mjs";
+export { default as mergeRight } from "./merge/merge-right.mjs";
+export { default as mergeLeft } from "./merge/merge-left.mjs";

package/src/media-types.cjs

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomError = require("@speclynx/apidom-error");
+/**
+ * @public
+ */
+class MediaTypes extends Array {
+  unknownMediaType = 'application/octet-stream';
+  filterByFormat() {
+    throw new _apidomError.NotImplementedError('filterByFormat method in MediaTypes class is not yet implemented.');
+  }
+  findBy() {
+    throw new _apidomError.NotImplementedError('findBy method in MediaTypes class is not yet implemented.');
+  }
+  latest() {
+    throw new _apidomError.NotImplementedError('latest method in MediaTypes class is not yet implemented.');
+  }
+}
+var _default = exports.default = MediaTypes;

package/src/media-types.mjs

@@ -0,0 +1,18 @@
+import { NotImplementedError } from '@speclynx/apidom-error';
+
+/**
+ * @public
+ */
+class MediaTypes extends Array {
+  unknownMediaType = 'application/octet-stream';
+  filterByFormat() {
+    throw new NotImplementedError('filterByFormat method in MediaTypes class is not yet implemented.');
+  }
+  findBy() {
+    throw new NotImplementedError('findBy method in MediaTypes class is not yet implemented.');
+  }
+  latest() {
+    throw new NotImplementedError('latest method in MediaTypes class is not yet implemented.');
+  }
+}
+export default MediaTypes;

package/src/merge/deepmerge.cjs

@@ -0,0 +1,151 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.emptyElement = exports.defaultOptions = exports.default = void 0;
+var _minim = require("minim");
+var _index = require("../predicates/index.cjs");
+var _index2 = require("../clone/index.cjs");
+var _index3 = _interopRequireDefault(require("../transformers/serializers/value/index.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+const emptyElement = element => {
+  const meta = element.meta.length > 0 ? (0, _index2.cloneDeep)(element.meta) : undefined;
+  const attributes = element.attributes.length > 0 ? (0, _index2.cloneDeep)(element.attributes) : undefined;
+
+  // @ts-ignore
+  return new element.constructor(undefined, meta, attributes);
+};
+exports.emptyElement = emptyElement;
+const cloneUnlessOtherwiseSpecified = (element, options) => options.clone && options.isMergeableElement(element) ? deepmerge(emptyElement(element), element, options) : element;
+const getMergeFunction = (keyElement, options) => {
+  if (typeof options.customMerge !== 'function') {
+    return deepmerge;
+  }
+  const customMerge = options.customMerge(keyElement, options);
+  return typeof customMerge === 'function' ? customMerge : deepmerge;
+};
+const getMetaMergeFunction = options => {
+  if (typeof options.customMetaMerge !== 'function') {
+    return targetMeta => (0, _index2.cloneDeep)(targetMeta);
+  }
+  return options.customMetaMerge;
+};
+const getAttributesMergeFunction = options => {
+  if (typeof options.customAttributesMerge !== 'function') {
+    return targetAttributes => (0, _index2.cloneDeep)(targetAttributes);
+  }
+  return options.customAttributesMerge;
+};
+const mergeArrayElement = (targetElement, sourceElement, options) => targetElement.concat(sourceElement)['fantasy-land/map'](item => cloneUnlessOtherwiseSpecified(item, options));
+const mergeObjectElement = (targetElement, sourceElement, options) => {
+  const destination = (0, _index.isObjectElement)(targetElement) ? emptyElement(targetElement) : emptyElement(sourceElement);
+  if ((0, _index.isObjectElement)(targetElement)) {
+    targetElement.forEach((value, key, member) => {
+      const clonedMember = (0, _index2.cloneShallow)(member);
+      clonedMember.value = cloneUnlessOtherwiseSpecified(value, options);
+      destination.content.push(clonedMember);
+    });
+  }
+  sourceElement.forEach((value, key, member) => {
+    const keyValue = (0, _index3.default)(key);
+    let clonedMember;
+    if ((0, _index.isObjectElement)(targetElement) && targetElement.hasKey(keyValue) && options.isMergeableElement(value)) {
+      const targetValue = targetElement.get(keyValue);
+      clonedMember = (0, _index2.cloneShallow)(member);
+      clonedMember.value = getMergeFunction(key, options)(targetValue, value, options);
+    } else {
+      clonedMember = (0, _index2.cloneShallow)(member);
+      clonedMember.value = cloneUnlessOtherwiseSpecified(value, options);
+    }
+    destination.remove(keyValue);
+    destination.content.push(clonedMember);
+  });
+  return destination;
+};
+const defaultOptions = exports.defaultOptions = {
+  clone: true,
+  isMergeableElement: element => (0, _index.isObjectElement)(element) || (0, _index.isArrayElement)(element),
+  arrayElementMerge: mergeArrayElement,
+  objectElementMerge: mergeObjectElement,
+  customMerge: undefined,
+  customMetaMerge: undefined,
+  customAttributesMerge: undefined
+};
+
+/**
+ * @public
+ */
+const deepmerge = (targetElement, sourceElement, options) => {
+  const mergedOptions = {
+    ...defaultOptions,
+    ...options
+  };
+  mergedOptions.isMergeableElement = mergedOptions.isMergeableElement ?? defaultOptions.isMergeableElement;
+  mergedOptions.arrayElementMerge = mergedOptions.arrayElementMerge ?? defaultOptions.arrayElementMerge;
+  mergedOptions.objectElementMerge = mergedOptions.objectElementMerge ?? defaultOptions.objectElementMerge;
+  const sourceIsArrayElement = (0, _index.isArrayElement)(sourceElement);
+  const targetIsArrayElement = (0, _index.isArrayElement)(targetElement);
+  const sourceAndTargetTypesMatch = sourceIsArrayElement === targetIsArrayElement;
+  if (!sourceAndTargetTypesMatch) {
+    return cloneUnlessOtherwiseSpecified(sourceElement, mergedOptions);
+  }
+
+  // merging two elements
+  const mergedElement = sourceIsArrayElement && typeof mergedOptions.arrayElementMerge === 'function' ? mergedOptions.arrayElementMerge(targetElement, sourceElement, mergedOptions) : mergedOptions.objectElementMerge(targetElement, sourceElement, mergedOptions);
+
+  // merging meta & attributes
+  mergedElement.meta = getMetaMergeFunction(mergedOptions)(targetElement.meta, sourceElement.meta);
+  mergedElement.attributes = getAttributesMergeFunction(mergedOptions)(targetElement.attributes, sourceElement.attributes);
+  return mergedElement;
+};
+deepmerge.all = (list, options) => {
+  if (!Array.isArray(list)) {
+    throw new TypeError('First argument of deepmerge should be an array.');
+  }
+  if (list.length === 0) {
+    return new _minim.ObjectElement();
+  }
+  return list.reduce((target, source) => {
+    return deepmerge(target, source, options);
+  }, emptyElement(list[0]));
+};
+var _default = exports.default = deepmerge;

package/src/merge/deepmerge.mjs

@@ -0,0 +1,135 @@
+import { ObjectElement } from 'minim';
+import { isObjectElement, isArrayElement } from "../predicates/index.mjs";
+import { cloneDeep, cloneShallow } from "../clone/index.mjs";
+import toValue from "../transformers/serializers/value/index.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+export const emptyElement = element => {
+  const meta = element.meta.length > 0 ? cloneDeep(element.meta) : undefined;
+  const attributes = element.attributes.length > 0 ? cloneDeep(element.attributes) : undefined;
+
+  // @ts-ignore
+  return new element.constructor(undefined, meta, attributes);
+};
+const cloneUnlessOtherwiseSpecified = (element, options) => options.clone && options.isMergeableElement(element) ? deepmerge(emptyElement(element), element, options) : element;
+const getMergeFunction = (keyElement, options) => {
+  if (typeof options.customMerge !== 'function') {
+    return deepmerge;
+  }
+  const customMerge = options.customMerge(keyElement, options);
+  return typeof customMerge === 'function' ? customMerge : deepmerge;
+};
+const getMetaMergeFunction = options => {
+  if (typeof options.customMetaMerge !== 'function') {
+    return targetMeta => cloneDeep(targetMeta);
+  }
+  return options.customMetaMerge;
+};
+const getAttributesMergeFunction = options => {
+  if (typeof options.customAttributesMerge !== 'function') {
+    return targetAttributes => cloneDeep(targetAttributes);
+  }
+  return options.customAttributesMerge;
+};
+const mergeArrayElement = (targetElement, sourceElement, options) => targetElement.concat(sourceElement)['fantasy-land/map'](item => cloneUnlessOtherwiseSpecified(item, options));
+const mergeObjectElement = (targetElement, sourceElement, options) => {
+  const destination = isObjectElement(targetElement) ? emptyElement(targetElement) : emptyElement(sourceElement);
+  if (isObjectElement(targetElement)) {
+    targetElement.forEach((value, key, member) => {
+      const clonedMember = cloneShallow(member);
+      clonedMember.value = cloneUnlessOtherwiseSpecified(value, options);
+      destination.content.push(clonedMember);
+    });
+  }
+  sourceElement.forEach((value, key, member) => {
+    const keyValue = toValue(key);
+    let clonedMember;
+    if (isObjectElement(targetElement) && targetElement.hasKey(keyValue) && options.isMergeableElement(value)) {
+      const targetValue = targetElement.get(keyValue);
+      clonedMember = cloneShallow(member);
+      clonedMember.value = getMergeFunction(key, options)(targetValue, value, options);
+    } else {
+      clonedMember = cloneShallow(member);
+      clonedMember.value = cloneUnlessOtherwiseSpecified(value, options);
+    }
+    destination.remove(keyValue);
+    destination.content.push(clonedMember);
+  });
+  return destination;
+};
+export const defaultOptions = {
+  clone: true,
+  isMergeableElement: element => isObjectElement(element) || isArrayElement(element),
+  arrayElementMerge: mergeArrayElement,
+  objectElementMerge: mergeObjectElement,
+  customMerge: undefined,
+  customMetaMerge: undefined,
+  customAttributesMerge: undefined
+};
+
+/**
+ * @public
+ */
+const deepmerge = (targetElement, sourceElement, options) => {
+  const mergedOptions = {
+    ...defaultOptions,
+    ...options
+  };
+  mergedOptions.isMergeableElement = mergedOptions.isMergeableElement ?? defaultOptions.isMergeableElement;
+  mergedOptions.arrayElementMerge = mergedOptions.arrayElementMerge ?? defaultOptions.arrayElementMerge;
+  mergedOptions.objectElementMerge = mergedOptions.objectElementMerge ?? defaultOptions.objectElementMerge;
+  const sourceIsArrayElement = isArrayElement(sourceElement);
+  const targetIsArrayElement = isArrayElement(targetElement);
+  const sourceAndTargetTypesMatch = sourceIsArrayElement === targetIsArrayElement;
+  if (!sourceAndTargetTypesMatch) {
+    return cloneUnlessOtherwiseSpecified(sourceElement, mergedOptions);
+  }
+
+  // merging two elements
+  const mergedElement = sourceIsArrayElement && typeof mergedOptions.arrayElementMerge === 'function' ? mergedOptions.arrayElementMerge(targetElement, sourceElement, mergedOptions) : mergedOptions.objectElementMerge(targetElement, sourceElement, mergedOptions);
+
+  // merging meta & attributes
+  mergedElement.meta = getMetaMergeFunction(mergedOptions)(targetElement.meta, sourceElement.meta);
+  mergedElement.attributes = getAttributesMergeFunction(mergedOptions)(targetElement.attributes, sourceElement.attributes);
+  return mergedElement;
+};
+deepmerge.all = (list, options) => {
+  if (!Array.isArray(list)) {
+    throw new TypeError('First argument of deepmerge should be an array.');
+  }
+  if (list.length === 0) {
+    return new ObjectElement();
+  }
+  return list.reduce((target, source) => {
+    return deepmerge(target, source, options);
+  }, emptyElement(list[0]));
+};
+export default deepmerge;

package/src/merge/merge-left.cjs

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _mergeRight = _interopRequireDefault(require("./merge-right.cjs"));
+/**
+ * @public
+ */
+const mergeLeft = (...[sourceElement, targetElement, options]) => {
+  return (0, _mergeRight.default)(targetElement, sourceElement, options);
+};
+mergeLeft.all = (...[list, options]) => {
+  return _mergeRight.default.all([...list].reverse(), options);
+};
+var _default = exports.default = mergeLeft;

package/src/merge/merge-left.mjs

@@ -0,0 +1,11 @@
+import mergeRight from "./merge-right.mjs";
+/**
+ * @public
+ */
+const mergeLeft = (...[sourceElement, targetElement, options]) => {
+  return mergeRight(targetElement, sourceElement, options);
+};
+mergeLeft.all = (...[list, options]) => {
+  return mergeRight.all([...list].reverse(), options);
+};
+export default mergeLeft;

package/src/merge/merge-right.cjs

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _minim = require("minim");
+var _deepmerge = _interopRequireWildcard(require("./deepmerge.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+const mergeRight = (targetElement, sourceElement, options) => {
+  const mergedOptions = {
+    ..._deepmerge.defaultOptions,
+    ...options,
+    customMerge: () => (target, source) => source,
+    clone: false
+  };
+  return (0, _deepmerge.default)(targetElement, sourceElement, mergedOptions);
+};
+mergeRight.all = (list, options) => {
+  if (!Array.isArray(list)) {
+    throw new TypeError('First argument of mergeRight should be an array.');
+  }
+  if (list.length === 0) {
+    return new _minim.ObjectElement();
+  }
+  return list.reduce((target, source) => {
+    return mergeRight(target, source, options);
+  }, (0, _deepmerge.emptyElement)(list[0]));
+};
+var _default = exports.default = mergeRight;

package/src/merge/merge-right.mjs

@@ -0,0 +1,29 @@
+import { ObjectElement } from 'minim';
+import deepmerge, { defaultOptions as defaultDeepmergeOptions, emptyElement } from "./deepmerge.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+const mergeRight = (targetElement, sourceElement, options) => {
+  const mergedOptions = {
+    ...defaultDeepmergeOptions,
+    ...options,
+    customMerge: () => (target, source) => source,
+    clone: false
+  };
+  return deepmerge(targetElement, sourceElement, mergedOptions);
+};
+mergeRight.all = (list, options) => {
+  if (!Array.isArray(list)) {
+    throw new TypeError('First argument of mergeRight should be an array.');
+  }
+  if (list.length === 0) {
+    return new ObjectElement();
+  }
+  return list.reduce((target, source) => {
+    return mergeRight(target, source, options);
+  }, emptyElement(list[0]));
+};
+export default mergeRight;

package/src/namespace.cjs

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = exports.createNamespace = exports.Namespace = void 0;
+var _minim = require("minim");
+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"));
+/**
+ * @public
+ */
+class Namespace extends _minim.Namespace {
+  constructor() {
+    super();
+    this.register('annotation', _Annotation.default);
+    this.register('comment', _Comment.default);
+    this.register('parseResult', _ParseResult.default);
+    this.register('sourceMap', _SourceMap.default);
+  }
+}
+
+/**
+ * @public
+ */
+exports.Namespace = Namespace;
+const namespace = new Namespace();
+
+/**
+ * @public
+ */
+const createNamespace = namespacePlugin => {
+  const namespaceInstance = new Namespace();
+  if ((0, _ramdaAdjunct.isPlainObject)(namespacePlugin)) {
+    namespaceInstance.use(namespacePlugin);
+  }
+  return namespaceInstance;
+};
+exports.createNamespace = createNamespace;
+var _default = exports.default = namespace;

package/src/namespace.mjs

@@ -0,0 +1,35 @@
+import { Namespace as MinimNamespace } from 'minim';
+import { isPlainObject } from 'ramda-adjunct';
+import AnnotationElement from "./elements/Annotation.mjs";
+import CommentElement from "./elements/Comment.mjs";
+import ParseResultElement from "./elements/ParseResult.mjs";
+import SourceMapElement from "./elements/SourceMap.mjs";
+/**
+ * @public
+ */
+export class Namespace extends MinimNamespace {
+  constructor() {
+    super();
+    this.register('annotation', AnnotationElement);
+    this.register('comment', CommentElement);
+    this.register('parseResult', ParseResultElement);
+    this.register('sourceMap', SourceMapElement);
+  }
+}
+
+/**
+ * @public
+ */
+const namespace = new Namespace();
+
+/**
+ * @public
+ */
+export const createNamespace = namespacePlugin => {
+  const namespaceInstance = new Namespace();
+  if (isPlainObject(namespacePlugin)) {
+    namespaceInstance.use(namespacePlugin);
+  }
+  return namespaceInstance;
+};
+export default namespace;

package/src/predicates/helpers.cjs

@@ -0,0 +1,85 @@
+"use strict";
+
+exports.__esModule = true;
+exports.primitiveEq = exports.isElementType = exports.hasMethod = exports.hasClass = exports.hasBasicElementProps = exports.default = void 0;
+var _minim = require("minim");
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+const hasMethod = (name, element) => {
+  return typeof element === 'object' && element !== null && name in element && typeof element[name] === 'function';
+};
+
+/**
+ * @public
+ */
+exports.hasMethod = hasMethod;
+const hasBasicElementProps = element => typeof element === 'object' && element != null && '_storedElement' in element && typeof element._storedElement === 'string' && '_content' in element;
+
+/**
+ * @public
+ */
+exports.hasBasicElementProps = hasBasicElementProps;
+const primitiveEq = (val, element) => {
+  if (typeof element === 'object' && element !== null && 'primitive' in element) {
+    return typeof element.primitive === 'function' && element.primitive() === val;
+  }
+  return false;
+};
+
+/**
+ * @public
+ */
+exports.primitiveEq = primitiveEq;
+const hasClass = (cls, element) => {
+  return typeof element === 'object' && element !== null && 'classes' in element && (Array.isArray(element.classes) || element.classes instanceof _minim.ArrayElement) && element.classes.includes(cls);
+};
+
+/**
+ * @public
+ */
+exports.hasClass = hasClass;
+const isElementType = (name, element) => typeof element === 'object' && element !== null && 'element' in element && element.element === name;
+
+/**
+ * @public
+ */
+exports.isElementType = isElementType;
+const createPredicate = predicateCreator => {
+  return predicateCreator({
+    hasMethod,
+    hasBasicElementProps,
+    primitiveEq,
+    isElementType,
+    hasClass
+  });
+};
+var _default = exports.default = createPredicate;