@speclynx/apidom-parser-adapter-yaml-1-2 1.12.1 → 2.0.1

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlNode.cjs

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _Node = _interopRequireDefault(require("../Node.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class YamlNode extends _Node.default {
+  anchor;
+  tag;
+  style;
+  styleGroup;
+  constructor({
+    anchor,
+    tag,
+    style,
+    styleGroup,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.anchor = anchor;
+    this.tag = tag;
+    this.style = style;
+    this.styleGroup = styleGroup;
+  }
+}
+var _default = exports.default = YamlNode;

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlNode.mjs

@@ -0,0 +1,29 @@
+import Node from "../Node.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class YamlNode extends Node {
+  anchor;
+  tag;
+  style;
+  styleGroup;
+  constructor({
+    anchor,
+    tag,
+    style,
+    styleGroup,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.anchor = anchor;
+    this.tag = tag;
+    this.style = style;
+    this.styleGroup = styleGroup;
+  }
+}
+export default YamlNode;

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlScalar.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _YamlNode = _interopRequireDefault(require("./YamlNode.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class YamlScalar extends _YamlNode.default {
+  static type = 'scalar';
+  content;
+  constructor({
+    content,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.content = content;
+  }
+}
+var _default = exports.default = YamlScalar;

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlScalar.mjs

@@ -0,0 +1,21 @@
+import YamlNode from "./YamlNode.mjs";
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class YamlScalar extends YamlNode {
+  static type = 'scalar';
+  content;
+  constructor({
+    content,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.content = content;
+  }
+}
+export default YamlScalar;

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlSequence.cjs

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _YamlCollection = _interopRequireDefault(require("./YamlCollection.cjs"));
+var _predicates = require("./predicates.cjs");
+/**
+ * @public
+ */
+class YamlSequence extends _YamlCollection.default {
+  static type = 'sequence';
+}
+Object.defineProperty(YamlSequence.prototype, 'content', {
+  get() {
+    const {
+      children
+    } = this;
+    return Array.isArray(children) ? children.filter(node => (0, _predicates.isSequence)(node) || (0, _predicates.isMapping)(node) || (0, _predicates.isScalar)(node) || (0, _predicates.isAlias)(node)) : [];
+  },
+  enumerable: true
+});
+var _default = exports.default = YamlSequence;

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlSequence.mjs

@@ -0,0 +1,18 @@
+import YamlCollection from "./YamlCollection.mjs";
+import { isScalar, isMapping, isSequence, isAlias } from "./predicates.mjs";
+/**
+ * @public
+ */
+class YamlSequence extends YamlCollection {
+  static type = 'sequence';
+}
+Object.defineProperty(YamlSequence.prototype, 'content', {
+  get() {
+    const {
+      children
+    } = this;
+    return Array.isArray(children) ? children.filter(node => isSequence(node) || isMapping(node) || isScalar(node) || isAlias(node)) : [];
+  },
+  enumerable: true
+});
+export default YamlSequence;

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlStream.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _Node = _interopRequireDefault(require("../Node.cjs"));
+var _predicates = require("./predicates.cjs");
+/**
+ * @public
+ */
+class YamlStream extends _Node.default {
+  static type = 'stream';
+}
+Object.defineProperty(YamlStream.prototype, 'content', {
+  get() {
+    return Array.isArray(this.children) ? this.children.filter(node => (0, _predicates.isDocument)(node) || (0, _predicates.isComment)(node)) : [];
+  },
+  enumerable: true
+});
+var _default = exports.default = YamlStream;

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlStream.mjs

@@ -0,0 +1,15 @@
+import Node from "../Node.mjs";
+import { isDocument, isComment } from "./predicates.mjs";
+/**
+ * @public
+ */
+class YamlStream extends Node {
+  static type = 'stream';
+}
+Object.defineProperty(YamlStream.prototype, 'content', {
+  get() {
+    return Array.isArray(this.children) ? this.children.filter(node => isDocument(node) || isComment(node)) : [];
+  },
+  enumerable: true
+});
+export default YamlStream;

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlStyle.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+exports.__esModule = true;
+exports.YamlStyleGroup = exports.YamlStyle = void 0;
+/**
+ * @public
+ */
+let YamlStyle = exports.YamlStyle = /*#__PURE__*/function (YamlStyle) {
+  YamlStyle["Plain"] = "Plain";
+  YamlStyle["SingleQuoted"] = "SingleQuoted";
+  YamlStyle["DoubleQuoted"] = "DoubleQuoted";
+  YamlStyle["Literal"] = "Literal";
+  YamlStyle["Folded"] = "Folded";
+  YamlStyle["Explicit"] = "Explicit";
+  YamlStyle["SinglePair"] = "SinglePair";
+  YamlStyle["NextLine"] = "NextLine";
+  YamlStyle["InLine"] = "InLine";
+  return YamlStyle;
+}({});
+/**
+ * @public
+ */
+let YamlStyleGroup = exports.YamlStyleGroup = /*#__PURE__*/function (YamlStyleGroup) {
+  YamlStyleGroup["Flow"] = "Flow";
+  YamlStyleGroup["Block"] = "Block";
+  return YamlStyleGroup;
+}({});

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlStyle.mjs

@@ -0,0 +1,24 @@
+/**
+ * @public
+ */
+export let YamlStyle = /*#__PURE__*/function (YamlStyle) {
+  YamlStyle["Plain"] = "Plain";
+  YamlStyle["SingleQuoted"] = "SingleQuoted";
+  YamlStyle["DoubleQuoted"] = "DoubleQuoted";
+  YamlStyle["Literal"] = "Literal";
+  YamlStyle["Folded"] = "Folded";
+  YamlStyle["Explicit"] = "Explicit";
+  YamlStyle["SinglePair"] = "SinglePair";
+  YamlStyle["NextLine"] = "NextLine";
+  YamlStyle["InLine"] = "InLine";
+  return YamlStyle;
+}({});
+
+/**
+ * @public
+ */
+export let YamlStyleGroup = /*#__PURE__*/function (YamlStyleGroup) {
+  YamlStyleGroup["Flow"] = "Flow";
+  YamlStyleGroup["Block"] = "Block";
+  return YamlStyleGroup;
+}({});

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlTag.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = exports.YamlNodeKind = void 0;
+var _Node = _interopRequireDefault(require("../Node.cjs"));
+/**
+ * @public
+ */
+let YamlNodeKind = exports.YamlNodeKind = /*#__PURE__*/function (YamlNodeKind) {
+  YamlNodeKind["Scalar"] = "Scalar";
+  YamlNodeKind["Sequence"] = "Sequence";
+  YamlNodeKind["Mapping"] = "Mapping";
+  return YamlNodeKind;
+}({});
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+class YamlTag extends _Node.default {
+  static type = 'tag';
+  explicitName;
+  kind;
+  constructor({
+    explicitName,
+    kind,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.explicitName = explicitName;
+    this.kind = kind;
+  }
+}
+var _default = exports.default = YamlTag;

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlTag.mjs

@@ -0,0 +1,35 @@
+import Node from "../Node.mjs";
+/**
+ * @public
+ */
+export let YamlNodeKind = /*#__PURE__*/function (YamlNodeKind) {
+  YamlNodeKind["Scalar"] = "Scalar";
+  YamlNodeKind["Sequence"] = "Sequence";
+  YamlNodeKind["Mapping"] = "Mapping";
+  return YamlNodeKind;
+}({});
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class YamlTag extends Node {
+  static type = 'tag';
+  explicitName;
+  kind;
+  constructor({
+    explicitName,
+    kind,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.explicitName = explicitName;
+    this.kind = kind;
+  }
+}
+export default YamlTag;

package/src/tree-sitter/syntactic-analysis/ast/nodes/predicates.cjs

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.isSequence = exports.isScalar = exports.isMapping = exports.isKeyValuePair = exports.isDocument = exports.isComment = exports.isAlias = void 0;
+var _YamlScalar = _interopRequireDefault(require("./YamlScalar.cjs"));
+var _YamlMapping = _interopRequireDefault(require("./YamlMapping.cjs"));
+var _YamlSequence = _interopRequireDefault(require("./YamlSequence.cjs"));
+var _YamlAlias = _interopRequireDefault(require("./YamlAlias.cjs"));
+var _YamlKeyValuePair = _interopRequireDefault(require("./YamlKeyValuePair.cjs"));
+var _YamlDocument = _interopRequireDefault(require("./YamlDocument.cjs"));
+var _YamlComment = _interopRequireDefault(require("./YamlComment.cjs"));
+const isScalar = node => node instanceof _YamlScalar.default;
+exports.isScalar = isScalar;
+const isMapping = node => node instanceof _YamlMapping.default;
+exports.isMapping = isMapping;
+const isSequence = node => node instanceof _YamlSequence.default;
+exports.isSequence = isSequence;
+const isAlias = node => node instanceof _YamlAlias.default;
+exports.isAlias = isAlias;
+const isKeyValuePair = node => node instanceof _YamlKeyValuePair.default;
+exports.isKeyValuePair = isKeyValuePair;
+const isDocument = node => node instanceof _YamlDocument.default;
+exports.isDocument = isDocument;
+const isComment = node => node instanceof _YamlComment.default;
+exports.isComment = isComment;

package/src/tree-sitter/syntactic-analysis/ast/nodes/predicates.mjs

@@ -0,0 +1,14 @@
+import YamlScalar from "./YamlScalar.mjs";
+import YamlMapping from "./YamlMapping.mjs";
+import YamlSequence from "./YamlSequence.mjs";
+import YamlAlias from "./YamlAlias.mjs";
+import YamlKeyValuePair from "./YamlKeyValuePair.mjs";
+import YamlDocument from "./YamlDocument.mjs";
+import YamlComment from "./YamlComment.mjs";
+export const isScalar = node => node instanceof YamlScalar;
+export const isMapping = node => node instanceof YamlMapping;
+export const isSequence = node => node instanceof YamlSequence;
+export const isAlias = node => node instanceof YamlAlias;
+export const isKeyValuePair = node => node instanceof YamlKeyValuePair;
+export const isDocument = node => node instanceof YamlDocument;
+export const isComment = node => node instanceof YamlComment;

package/src/tree-sitter/syntactic-analysis/ast/schemas/ScalarTag.cjs

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _canonicalFormat = require("./canonical-format.cjs");
+var _YamlStyle = require("../nodes/YamlStyle.cjs");
+var _YamlTag = require("../nodes/YamlTag.cjs");
+class ScalarTag {
+  static test(node) {
+    return node.tag.kind === _YamlTag.YamlNodeKind.Scalar && typeof node.content === 'string';
+  }
+  static canonicalFormat(node) {
+    let canonicalForm = node.content;
+    const nodeClone = node.clone();
+    if (node.style === _YamlStyle.YamlStyle.Plain) {
+      canonicalForm = (0, _canonicalFormat.formatFlowPlain)(node.content);
+    } else if (node.style === _YamlStyle.YamlStyle.SingleQuoted) {
+      canonicalForm = (0, _canonicalFormat.formatFlowSingleQuoted)(node.content);
+    } else if (node.style === _YamlStyle.YamlStyle.DoubleQuoted) {
+      canonicalForm = (0, _canonicalFormat.formatFlowDoubleQuoted)(node.content);
+    } else if (node.style === _YamlStyle.YamlStyle.Literal) {
+      canonicalForm = (0, _canonicalFormat.formatBlockLiteral)(node.content);
+    } else if (node.style === _YamlStyle.YamlStyle.Folded) {
+      canonicalForm = (0, _canonicalFormat.formatBlockFolded)(node.content);
+    }
+    nodeClone.content = canonicalForm;
+    return nodeClone;
+  }
+  static resolve(node) {
+    return node;
+  }
+}
+var _default = exports.default = ScalarTag;

package/src/tree-sitter/syntactic-analysis/ast/schemas/ScalarTag.mjs

@@ -0,0 +1,29 @@
+import { formatFlowPlain, formatFlowSingleQuoted, formatFlowDoubleQuoted, formatBlockLiteral, formatBlockFolded } from "./canonical-format.mjs";
+import { YamlStyle } from "../nodes/YamlStyle.mjs";
+import { YamlNodeKind } from "../nodes/YamlTag.mjs";
+class ScalarTag {
+  static test(node) {
+    return node.tag.kind === YamlNodeKind.Scalar && typeof node.content === 'string';
+  }
+  static canonicalFormat(node) {
+    let canonicalForm = node.content;
+    const nodeClone = node.clone();
+    if (node.style === YamlStyle.Plain) {
+      canonicalForm = formatFlowPlain(node.content);
+    } else if (node.style === YamlStyle.SingleQuoted) {
+      canonicalForm = formatFlowSingleQuoted(node.content);
+    } else if (node.style === YamlStyle.DoubleQuoted) {
+      canonicalForm = formatFlowDoubleQuoted(node.content);
+    } else if (node.style === YamlStyle.Literal) {
+      canonicalForm = formatBlockLiteral(node.content);
+    } else if (node.style === YamlStyle.Folded) {
+      canonicalForm = formatBlockFolded(node.content);
+    }
+    nodeClone.content = canonicalForm;
+    return nodeClone;
+  }
+  static resolve(node) {
+    return node;
+  }
+}
+export default ScalarTag;

package/src/tree-sitter/syntactic-analysis/ast/schemas/Tag.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+class Tag {
+  static uri = '';
+  tag = '';
+  constructor() {
+    this.tag = this.constructor.uri;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  test(node) {
+    return true;
+  }
+  resolve(node) {
+    return node;
+  }
+}
+var _default = exports.default = Tag;

package/src/tree-sitter/syntactic-analysis/ast/schemas/Tag.mjs

@@ -0,0 +1,16 @@
+class Tag {
+  static uri = '';
+  tag = '';
+  constructor() {
+    this.tag = this.constructor.uri;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  test(node) {
+    return true;
+  }
+  resolve(node) {
+    return node;
+  }
+}
+export default Tag;

package/src/tree-sitter/syntactic-analysis/ast/schemas/canonical-format.cjs

@@ -0,0 +1,127 @@
+"use strict";
+
+exports.__esModule = true;
+exports.formatFlowSingleQuoted = exports.formatFlowPlain = exports.formatFlowDoubleQuoted = exports.formatBlockLiteral = exports.formatBlockFolded = void 0;
+var _ramda = require("ramda");
+var _ramdaAdjunct = require("ramda-adjunct");
+var _unraw = require("unraw");
+/**
+ * Helpers.
+ */
+
+const blockStyleRegExp = /^(?<style>[|>])(?<chomping>[+-]?)(?<indentation>[0-9]*)\s/;
+const getIndentationIndicator = content => {
+  const matches = content.match(blockStyleRegExp);
+  const indicator = (0, _ramda.pathOr)('', ['groups', 'indentation'], matches);
+  return (0, _ramdaAdjunct.isEmptyString)(indicator) ? undefined : parseInt(indicator, 10);
+};
+const getIndentation = content => {
+  const explicitIndentationIndicator = getIndentationIndicator(content);
+
+  // we have explicit indentation indicator
+  if ((0, _ramdaAdjunct.isInteger)(explicitIndentationIndicator)) {
+    return (0, _ramdaAdjunct.repeatStr)(' ', explicitIndentationIndicator);
+  }
+
+  // we assume indentation indicator from first line
+  const firstLine = (0, _ramda.pathOr)('', [1], content.split('\n'));
+  const implicitIndentationIndicator = (0, _ramda.pathOr)(0, ['groups', 'indentation', 'length'], firstLine.match(/^(?<indentation>[ ]*)/));
+  return (0, _ramdaAdjunct.repeatStr)(' ', implicitIndentationIndicator);
+};
+const getChompingIndicator = content => {
+  const matches = content.match(blockStyleRegExp);
+  const indicator = (0, _ramda.pathOr)('', ['groups', 'chomping'], matches);
+  return (0, _ramdaAdjunct.isEmptyString)(indicator) ? undefined : indicator;
+};
+const chomp = (indicator, content) => {
+  // clip (single newline at end)
+  if ((0, _ramdaAdjunct.isUndefined)(indicator)) {
+    return `${(0, _ramdaAdjunct.trimEnd)(content)}\n`;
+  }
+  // strip (no newline at end)
+  if (indicator === '-') {
+    return (0, _ramdaAdjunct.trimEnd)(content);
+  }
+  // keep (all newlines from end)
+  if (indicator === '+') {
+    return content;
+  }
+  return content;
+};
+
+/**
+ * Normalizes lines breaks.
+ * https://yaml.org/spec/1.2/spec.html#line%20break/normalization/
+ */
+// @ts-ignore
+const normalizeLineBreaks = val => val.replace(/\r\n/g, '\n');
+
+// prevent escaped line breaks from being converted to a space
+const preventLineBreakCollapseToSpace = val => val.replace(/\\\n\s*/g, '');
+
+// collapse line breaks into spaces
+const collapseLineBreakToSpace = val => {
+  /**
+   * Safari doesn't support negative lookbehind, thus we use mimicking technique:
+   *
+   * - https://blog.stevenlevithan.com/archives/mimic-lookbehind-javascript
+   *
+   * Ideally we want to use following replace, but that's not currently possible:
+   *
+   * .replace(/[^\n]\n([^\n]+)/g, (match: string, p1: string) => ` ${p1.trimLeft()}`)
+   */
+  return val.replace(/(\n)?\n([^\n]+)/g, (match, p1, p2) => p1 ? match : ` ${p2.trimStart()}`).replace(/[\n]{2}/g, '\n');
+};
+const removeQuotes = (0, _ramda.curry)((quoteType, val) => val.replace(new RegExp(`^${quoteType}`), '').replace(new RegExp(`${quoteType}$`), ''));
+
+/**
+ * Formats Flow Scalar Plain style.
+ * https://yaml.org/spec/1.2/spec.html#id2788859
+ */
+const formatFlowPlain = exports.formatFlowPlain = (0, _ramda.pipe)(normalizeLineBreaks, _ramda.trim, collapseLineBreakToSpace, (0, _ramda.split)('\n'), (0, _ramda.map)(_ramdaAdjunct.trimStart), (0, _ramda.join)('\n'));
+
+/**
+ * Formats Flow Scalar Single-Quoted style.
+ * https://yaml.org/spec/1.2/spec.html#id2788097
+ */
+
+const formatFlowSingleQuoted = exports.formatFlowSingleQuoted = (0, _ramda.pipe)(normalizeLineBreaks, _ramda.trim, collapseLineBreakToSpace, (0, _ramda.split)('\n'), (0, _ramda.map)(_ramdaAdjunct.trimStart), (0, _ramda.join)('\n'), removeQuotes("'"));
+
+/**
+ * Formats Flow Scalar Double-Quoted style.
+ * https://yaml.org/spec/1.2/spec.html#id2787109
+ */
+const formatFlowDoubleQuoted = exports.formatFlowDoubleQuoted = (0, _ramda.pipe)(normalizeLineBreaks, _ramda.trim, preventLineBreakCollapseToSpace, collapseLineBreakToSpace, _unraw.unraw, (0, _ramda.split)('\n'), (0, _ramda.map)(_ramdaAdjunct.trimStart), (0, _ramda.join)('\n'), removeQuotes('"'));
+
+/**
+ * Formats Block Scalar Literal style.
+ * https://yaml.org/spec/1.2/spec.html#id2795688
+ */
+const formatBlockLiteral = content => {
+  const indentation = getIndentation(content);
+  const chompingIndicator = getChompingIndicator(content);
+  const normalized = normalizeLineBreaks(content);
+  const lines = (0, _ramda.tail)(normalized.split('\n')); // first line only contains indicators
+  const transducer = (0, _ramda.compose)((0, _ramda.map)((0, _ramdaAdjunct.trimCharsStart)(indentation)), (0, _ramda.map)((0, _ramdaAdjunct.concatRight)('\n')));
+  // @ts-ignore
+  const deindented = (0, _ramda.transduce)(transducer, _ramda.concat, '', lines);
+  return chomp(chompingIndicator, deindented);
+};
+
+/**
+ * Formats BLock Scalar Folded style.
+ * https://yaml.org/spec/1.2/spec.html#id2796251
+ */
+exports.formatBlockLiteral = formatBlockLiteral;
+const formatBlockFolded = content => {
+  const indentation = getIndentation(content);
+  const chompingIndicator = getChompingIndicator(content);
+  const normalized = normalizeLineBreaks(content);
+  const lines = (0, _ramda.tail)(normalized.split('\n')); // first line only contains indicators
+  const transducer = (0, _ramda.compose)((0, _ramda.map)((0, _ramdaAdjunct.trimCharsStart)(indentation)), (0, _ramda.map)((0, _ramdaAdjunct.concatRight)('\n')));
+  // @ts-ignore
+  const deindented = (0, _ramda.transduce)(transducer, _ramda.concat, '', lines);
+  const collapsed = collapseLineBreakToSpace(deindented);
+  return chomp(chompingIndicator, collapsed);
+};
+exports.formatBlockFolded = formatBlockFolded;