@speclynx/apidom-datamodel 4.0.2 → 4.0.3

package/src/clone/index.cjs

@@ -0,0 +1,188 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.cloneShallow = exports.cloneDeep = exports.ShallowCloneError = exports.DeepCloneError = exports.CloneError = void 0;
+var _ramda = require("ramda");
+var _ObjectSlice = _interopRequireDefault(require("../ObjectSlice.cjs"));
+var _KeyValuePair = _interopRequireDefault(require("../KeyValuePair.cjs"));
+var _index = require("../predicates/index.cjs");
+var _SourceMap = _interopRequireDefault(require("../elements/SourceMap.cjs"));
+var _DeepCloneError = _interopRequireDefault(require("./errors/DeepCloneError.cjs"));
+exports.DeepCloneError = _DeepCloneError.default;
+var _ShallowCloneError = _interopRequireDefault(require("./errors/ShallowCloneError.cjs"));
+exports.ShallowCloneError = _ShallowCloneError.default;
+var _CloneError = _interopRequireDefault(require("./errors/CloneError.cjs"));
+exports.CloneError = _CloneError.default;
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+const cloneDeepElement = (element, options) => {
+  const {
+    visited = new WeakMap()
+  } = options;
+  const passThroughOptions = {
+    ...options,
+    visited
+  };
+
+  // detect cycle and return memoized value
+  if (visited.has(element)) {
+    return visited.get(element);
+  }
+  const copy = cloneShallowElement(element);
+  visited.set(element, copy);
+  const {
+    content
+  } = element;
+  if (Array.isArray(content)) {
+    copy.content = content.map(el => cloneDeepElement(el, passThroughOptions));
+  } else if ((0, _index.isElement)(content)) {
+    copy.content = cloneDeepElement(content, passThroughOptions);
+  } else if (content instanceof _KeyValuePair.default) {
+    copy.content = cloneDeepKeyValuePair(content, passThroughOptions);
+  } else {
+    copy.content = content;
+  }
+  return copy;
+};
+const cloneDeepKeyValuePair = (kvp, options) => {
+  const {
+    visited = new WeakMap()
+  } = options;
+  const passThroughOptions = {
+    ...options,
+    visited
+  };
+  if (visited.has(kvp)) {
+    return visited.get(kvp);
+  }
+  const {
+    key,
+    value
+  } = kvp;
+  const keyCopy = key !== undefined ? cloneDeepElement(key, passThroughOptions) : undefined;
+  const valueCopy = value !== undefined ? cloneDeepElement(value, passThroughOptions) : undefined;
+  const copy = new _KeyValuePair.default(keyCopy, valueCopy);
+  visited.set(kvp, copy);
+  return copy;
+};
+const cloneDeepObjectSlice = (slice, options) => {
+  const {
+    visited = new WeakMap()
+  } = options;
+  const passThroughOptions = {
+    ...options,
+    visited
+  };
+  if (visited.has(slice)) {
+    return visited.get(slice);
+  }
+  const items = [...slice].map(element => cloneDeepElement(element, passThroughOptions));
+  const copy = new _ObjectSlice.default(items);
+  visited.set(slice, copy);
+  return copy;
+};
+
+/**
+ * Creates a deep clone of an ApiDOM Element, KeyValuePair, or ObjectSlice.
+ * Handles cycles by memoizing visited objects.
+ * @public
+ */
+const cloneDeep = (value, options = {}) => {
+  if (value instanceof _KeyValuePair.default) {
+    return cloneDeepKeyValuePair(value, options);
+  }
+  if (value instanceof _ObjectSlice.default) {
+    return cloneDeepObjectSlice(value, options);
+  }
+  if ((0, _index.isElement)(value)) {
+    return cloneDeepElement(value, options);
+  }
+  throw new _DeepCloneError.default("Value provided to cloneDeep function couldn't be cloned", {
+    value
+  });
+};
+exports.cloneDeep = cloneDeep;
+cloneDeep.safe = value => {
+  try {
+    return cloneDeep(value);
+  } catch {
+    return value;
+  }
+};
+const cloneShallowKeyValuePair = keyValuePair => {
+  const {
+    key,
+    value
+  } = keyValuePair;
+  return new _KeyValuePair.default(key, value);
+};
+const cloneShallowObjectSlice = objectSlice => {
+  const items = [...objectSlice];
+  return new _ObjectSlice.default(items);
+};
+const cloneShallowElement = element => {
+  const Ctor = element.constructor;
+  const copy = new Ctor();
+  copy.element = element.element;
+  if (!element.isMetaEmpty) {
+    copy.meta = element.meta.cloneDeep();
+  }
+  if (!element.isAttributesEmpty) {
+    copy.attributes = cloneDeep(element.attributes);
+  }
+  if ((0, _index.hasElementSourceMap)(element)) {
+    _SourceMap.default.transfer(element, copy);
+  }
+  if ((0, _index.hasElementStyle)(element)) {
+    copy.style = (0, _ramda.clone)(element.style);
+  }
+  const {
+    content
+  } = element;
+  if ((0, _index.isElement)(content)) {
+    copy.content = cloneShallowElement(content);
+  } else if (Array.isArray(content)) {
+    copy.content = [...content];
+  } else if (content instanceof _KeyValuePair.default) {
+    copy.content = cloneShallowKeyValuePair(content);
+  } else {
+    copy.content = content;
+  }
+  return copy;
+};
+
+/**
+ * Creates a shallow clone of an ApiDOM Element, KeyValuePair, or ObjectSlice.
+ * The element itself is cloned, but content references are shared.
+ * Meta and attributes are deep cloned to preserve semantic information.
+ * @public
+ */
+const cloneShallow = value => {
+  if (value instanceof _KeyValuePair.default) {
+    return cloneShallowKeyValuePair(value);
+  }
+  if (value instanceof _ObjectSlice.default) {
+    return cloneShallowObjectSlice(value);
+  }
+  if ((0, _index.isElement)(value)) {
+    return cloneShallowElement(value);
+  }
+  throw new _ShallowCloneError.default("Value provided to cloneShallow function couldn't be cloned", {
+    value
+  });
+};
+exports.cloneShallow = cloneShallow;
+cloneShallow.safe = value => {
+  try {
+    return cloneShallow(value);
+  } catch {
+    return value;
+  }
+};

package/src/clone/index.mjs

@@ -0,0 +1,178 @@
+import { clone } from 'ramda';
+import ObjectSlice from "../ObjectSlice.mjs";
+import KeyValuePair from "../KeyValuePair.mjs";
+import { isElement, hasElementSourceMap, hasElementStyle } from "../predicates/index.mjs";
+import SourceMapElement from "../elements/SourceMap.mjs";
+import DeepCloneError from "./errors/DeepCloneError.mjs";
+import ShallowCloneError from "./errors/ShallowCloneError.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+const cloneDeepElement = (element, options) => {
+  const {
+    visited = new WeakMap()
+  } = options;
+  const passThroughOptions = {
+    ...options,
+    visited
+  };
+
+  // detect cycle and return memoized value
+  if (visited.has(element)) {
+    return visited.get(element);
+  }
+  const copy = cloneShallowElement(element);
+  visited.set(element, copy);
+  const {
+    content
+  } = element;
+  if (Array.isArray(content)) {
+    copy.content = content.map(el => cloneDeepElement(el, passThroughOptions));
+  } else if (isElement(content)) {
+    copy.content = cloneDeepElement(content, passThroughOptions);
+  } else if (content instanceof KeyValuePair) {
+    copy.content = cloneDeepKeyValuePair(content, passThroughOptions);
+  } else {
+    copy.content = content;
+  }
+  return copy;
+};
+const cloneDeepKeyValuePair = (kvp, options) => {
+  const {
+    visited = new WeakMap()
+  } = options;
+  const passThroughOptions = {
+    ...options,
+    visited
+  };
+  if (visited.has(kvp)) {
+    return visited.get(kvp);
+  }
+  const {
+    key,
+    value
+  } = kvp;
+  const keyCopy = key !== undefined ? cloneDeepElement(key, passThroughOptions) : undefined;
+  const valueCopy = value !== undefined ? cloneDeepElement(value, passThroughOptions) : undefined;
+  const copy = new KeyValuePair(keyCopy, valueCopy);
+  visited.set(kvp, copy);
+  return copy;
+};
+const cloneDeepObjectSlice = (slice, options) => {
+  const {
+    visited = new WeakMap()
+  } = options;
+  const passThroughOptions = {
+    ...options,
+    visited
+  };
+  if (visited.has(slice)) {
+    return visited.get(slice);
+  }
+  const items = [...slice].map(element => cloneDeepElement(element, passThroughOptions));
+  const copy = new ObjectSlice(items);
+  visited.set(slice, copy);
+  return copy;
+};
+
+/**
+ * Creates a deep clone of an ApiDOM Element, KeyValuePair, or ObjectSlice.
+ * Handles cycles by memoizing visited objects.
+ * @public
+ */
+export const cloneDeep = (value, options = {}) => {
+  if (value instanceof KeyValuePair) {
+    return cloneDeepKeyValuePair(value, options);
+  }
+  if (value instanceof ObjectSlice) {
+    return cloneDeepObjectSlice(value, options);
+  }
+  if (isElement(value)) {
+    return cloneDeepElement(value, options);
+  }
+  throw new DeepCloneError("Value provided to cloneDeep function couldn't be cloned", {
+    value
+  });
+};
+cloneDeep.safe = value => {
+  try {
+    return cloneDeep(value);
+  } catch {
+    return value;
+  }
+};
+const cloneShallowKeyValuePair = keyValuePair => {
+  const {
+    key,
+    value
+  } = keyValuePair;
+  return new KeyValuePair(key, value);
+};
+const cloneShallowObjectSlice = objectSlice => {
+  const items = [...objectSlice];
+  return new ObjectSlice(items);
+};
+const cloneShallowElement = element => {
+  const Ctor = element.constructor;
+  const copy = new Ctor();
+  copy.element = element.element;
+  if (!element.isMetaEmpty) {
+    copy.meta = element.meta.cloneDeep();
+  }
+  if (!element.isAttributesEmpty) {
+    copy.attributes = cloneDeep(element.attributes);
+  }
+  if (hasElementSourceMap(element)) {
+    SourceMapElement.transfer(element, copy);
+  }
+  if (hasElementStyle(element)) {
+    copy.style = clone(element.style);
+  }
+  const {
+    content
+  } = element;
+  if (isElement(content)) {
+    copy.content = cloneShallowElement(content);
+  } else if (Array.isArray(content)) {
+    copy.content = [...content];
+  } else if (content instanceof KeyValuePair) {
+    copy.content = cloneShallowKeyValuePair(content);
+  } else {
+    copy.content = content;
+  }
+  return copy;
+};
+
+/**
+ * Creates a shallow clone of an ApiDOM Element, KeyValuePair, or ObjectSlice.
+ * The element itself is cloned, but content references are shared.
+ * Meta and attributes are deep cloned to preserve semantic information.
+ * @public
+ */
+export const cloneShallow = value => {
+  if (value instanceof KeyValuePair) {
+    return cloneShallowKeyValuePair(value);
+  }
+  if (value instanceof ObjectSlice) {
+    return cloneShallowObjectSlice(value);
+  }
+  if (isElement(value)) {
+    return cloneShallowElement(value);
+  }
+  throw new ShallowCloneError("Value provided to cloneShallow function couldn't be cloned", {
+    value
+  });
+};
+cloneShallow.safe = value => {
+  try {
+    return cloneShallow(value);
+  } catch {
+    return value;
+  }
+};
+export { default as CloneError } from "./errors/CloneError.mjs";
+export { default as DeepCloneError } from "./errors/DeepCloneError.mjs";
+export { default as ShallowCloneError } from "./errors/ShallowCloneError.mjs";

package/src/clone/index.ts

@@ -0,0 +1,195 @@
+import { clone } from 'ramda';
+
+import ObjectSlice from '../ObjectSlice.ts';
+import KeyValuePair from '../KeyValuePair.ts';
+import Element from '../primitives/Element.ts';
+import MemberElement from '../primitives/MemberElement.ts';
+import { isElement, hasElementSourceMap, hasElementStyle } from '../predicates/index.ts';
+import SourceMapElement from '../elements/SourceMap.ts';
+import DeepCloneError from './errors/DeepCloneError.ts';
+import ShallowCloneError from './errors/ShallowCloneError.ts';
+
+/**
+ * @public
+ */
+export type FinalCloneTypes = KeyValuePair | ObjectSlice;
+
+/**
+ * @public
+ */
+export type DeepCloneOptions = {
+  visited?: WeakMap<object, object>;
+};
+
+const cloneDeepElement = (element: Element, options: DeepCloneOptions): Element => {
+  const { visited = new WeakMap<object, object>() } = options;
+  const passThroughOptions = { ...options, visited };
+
+  // detect cycle and return memoized value
+  if (visited.has(element)) {
+    return visited.get(element) as Element;
+  }
+
+  const copy = cloneShallowElement(element);
+  visited.set(element, copy);
+
+  const { content } = element;
+  if (Array.isArray(content)) {
+    copy.content = content.map((el: Element) => cloneDeepElement(el, passThroughOptions));
+  } else if (isElement(content)) {
+    copy.content = cloneDeepElement(content as Element, passThroughOptions);
+  } else if ((content as unknown) instanceof KeyValuePair) {
+    copy.content = cloneDeepKeyValuePair(content as KeyValuePair, passThroughOptions);
+  } else {
+    copy.content = content;
+  }
+
+  return copy;
+};
+
+const cloneDeepKeyValuePair = (kvp: KeyValuePair, options: DeepCloneOptions): KeyValuePair => {
+  const { visited = new WeakMap<object, object>() } = options;
+  const passThroughOptions = { ...options, visited };
+
+  if (visited.has(kvp)) {
+    return visited.get(kvp) as KeyValuePair;
+  }
+
+  const { key, value } = kvp;
+  const keyCopy = key !== undefined ? cloneDeepElement(key, passThroughOptions) : undefined;
+  const valueCopy = value !== undefined ? cloneDeepElement(value, passThroughOptions) : undefined;
+  const copy = new KeyValuePair(keyCopy, valueCopy);
+  visited.set(kvp, copy);
+  return copy;
+};
+
+const cloneDeepObjectSlice = (slice: ObjectSlice, options: DeepCloneOptions): ObjectSlice => {
+  const { visited = new WeakMap<object, object>() } = options;
+  const passThroughOptions = { ...options, visited };
+
+  if (visited.has(slice)) {
+    return visited.get(slice) as ObjectSlice;
+  }
+
+  const items = [...slice].map(
+    (element) => cloneDeepElement(element, passThroughOptions) as MemberElement,
+  );
+  const copy = new ObjectSlice(items);
+  visited.set(slice, copy);
+  return copy;
+};
+
+/**
+ * Creates a deep clone of an ApiDOM Element, KeyValuePair, or ObjectSlice.
+ * Handles cycles by memoizing visited objects.
+ * @public
+ */
+export const cloneDeep = <T extends Element | FinalCloneTypes>(
+  value: T,
+  options: DeepCloneOptions = {},
+): T => {
+  if (value instanceof KeyValuePair) {
+    return cloneDeepKeyValuePair(value, options) as T;
+  }
+
+  if (value instanceof ObjectSlice) {
+    return cloneDeepObjectSlice(value, options) as T;
+  }
+
+  if (isElement(value)) {
+    return cloneDeepElement(value, options) as T;
+  }
+
+  throw new DeepCloneError("Value provided to cloneDeep function couldn't be cloned", {
+    value,
+  });
+};
+cloneDeep.safe = <T>(value: T): T => {
+  try {
+    return cloneDeep(value as Element | FinalCloneTypes) as T;
+  } catch {
+    return value;
+  }
+};
+
+const cloneShallowKeyValuePair = (keyValuePair: KeyValuePair): KeyValuePair => {
+  const { key, value } = keyValuePair;
+  return new KeyValuePair(key, value);
+};
+
+const cloneShallowObjectSlice = (objectSlice: ObjectSlice): ObjectSlice => {
+  const items = [...objectSlice];
+  return new ObjectSlice(items);
+};
+
+const cloneShallowElement = <T extends Element>(element: T): T => {
+  const Ctor = element.constructor as new () => T;
+  const copy = new Ctor();
+
+  copy.element = element.element;
+
+  if (!element.isMetaEmpty) {
+    copy.meta = element.meta.cloneDeep();
+  }
+
+  if (!element.isAttributesEmpty) {
+    copy.attributes = cloneDeep(element.attributes);
+  }
+
+  if (hasElementSourceMap(element)) {
+    SourceMapElement.transfer(element, copy);
+  }
+
+  if (hasElementStyle(element)) {
+    copy.style = clone(element.style);
+  }
+
+  const { content } = element;
+  if (isElement(content)) {
+    copy.content = cloneShallowElement(content as Element);
+  } else if (Array.isArray(content)) {
+    copy.content = [...content];
+  } else if ((content as unknown) instanceof KeyValuePair) {
+    copy.content = cloneShallowKeyValuePair(content as KeyValuePair);
+  } else {
+    copy.content = content;
+  }
+
+  return copy;
+};
+
+/**
+ * Creates a shallow clone of an ApiDOM Element, KeyValuePair, or ObjectSlice.
+ * The element itself is cloned, but content references are shared.
+ * Meta and attributes are deep cloned to preserve semantic information.
+ * @public
+ */
+export const cloneShallow = <T extends Element | FinalCloneTypes>(value: T): T => {
+  if (value instanceof KeyValuePair) {
+    return cloneShallowKeyValuePair(value) as T;
+  }
+
+  if (value instanceof ObjectSlice) {
+    return cloneShallowObjectSlice(value) as T;
+  }
+
+  if (isElement(value)) {
+    return cloneShallowElement(value) as T;
+  }
+
+  throw new ShallowCloneError("Value provided to cloneShallow function couldn't be cloned", {
+    value,
+  });
+};
+cloneShallow.safe = <T>(value: T): T => {
+  try {
+    return cloneShallow(value as Element | FinalCloneTypes) as T;
+  } catch {
+    return value;
+  }
+};
+
+export { default as CloneError } from './errors/CloneError.ts';
+export type { CloneErrorOptions } from './errors/CloneError.ts';
+export { default as DeepCloneError } from './errors/DeepCloneError.ts';
+export { default as ShallowCloneError } from './errors/ShallowCloneError.ts';

package/src/elements/Annotation.cjs

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _StringElement = _interopRequireDefault(require("../primitives/StringElement.cjs"));
+/**
+ * AnnotationElement represents a parsing annotation (warning or error).
+ *
+ * The annotation's class indicates its severity:
+ * - 'warning' - A non-fatal issue
+ * - 'error' - A fatal issue
+ *
+ * @public
+ */
+class AnnotationElement extends _StringElement.default {
+  constructor(content, meta, attributes) {
+    super(content, meta, attributes);
+    this.element = 'annotation';
+  }
+
+  /**
+   * The annotation code identifying the type of annotation.
+   */
+  get code() {
+    if (this.hasAttributesProperty('code')) {
+      return this.attributes.get('code');
+    }
+    return undefined;
+  }
+  set code(value) {
+    this.attributes.set('code', value);
+  }
+}
+var _default = exports.default = AnnotationElement;

package/src/elements/Annotation.mjs

@@ -0,0 +1,30 @@
+import StringElement from "../primitives/StringElement.mjs";
+/**
+ * AnnotationElement represents a parsing annotation (warning or error).
+ *
+ * The annotation's class indicates its severity:
+ * - 'warning' - A non-fatal issue
+ * - 'error' - A fatal issue
+ *
+ * @public
+ */
+class AnnotationElement extends StringElement {
+  constructor(content, meta, attributes) {
+    super(content, meta, attributes);
+    this.element = 'annotation';
+  }
+
+  /**
+   * The annotation code identifying the type of annotation.
+   */
+  get code() {
+    if (this.hasAttributesProperty('code')) {
+      return this.attributes.get('code');
+    }
+    return undefined;
+  }
+  set code(value) {
+    this.attributes.set('code', value);
+  }
+}
+export default AnnotationElement;

package/src/elements/Annotation.ts

@@ -0,0 +1,35 @@
+import StringElement from '../primitives/StringElement.ts';
+import type Element from '../primitives/Element.ts';
+import type { Meta, Attributes } from '../types.ts';
+
+/**
+ * AnnotationElement represents a parsing annotation (warning or error).
+ *
+ * The annotation's class indicates its severity:
+ * - 'warning' - A non-fatal issue
+ * - 'error' - A fatal issue
+ *
+ * @public
+ */
+class AnnotationElement extends StringElement {
+  constructor(content?: string, meta?: Meta, attributes?: Attributes) {
+    super(content, meta, attributes);
+    this.element = 'annotation';
+  }
+
+  /**
+   * The annotation code identifying the type of annotation.
+   */
+  get code(): Element | undefined {
+    if (this.hasAttributesProperty('code')) {
+      return this.attributes.get('code') as Element;
+    }
+    return undefined;
+  }
+
+  set code(value: unknown) {
+    this.attributes.set('code', value);
+  }
+}
+
+export default AnnotationElement;

package/src/elements/Comment.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _StringElement = _interopRequireDefault(require("../primitives/StringElement.cjs"));
+/**
+ * CommentElement represents a comment in the source document.
+ *
+ * @public
+ */
+class CommentElement extends _StringElement.default {
+  constructor(content, meta, attributes) {
+    super(content, meta, attributes);
+    this.element = 'comment';
+  }
+}
+var _default = exports.default = CommentElement;

package/src/elements/Comment.mjs

@@ -0,0 +1,13 @@
+import StringElement from "../primitives/StringElement.mjs";
+/**
+ * CommentElement represents a comment in the source document.
+ *
+ * @public
+ */
+class CommentElement extends StringElement {
+  constructor(content, meta, attributes) {
+    super(content, meta, attributes);
+    this.element = 'comment';
+  }
+}
+export default CommentElement;