@swagger-api/apidom-ast 0.92.0 → 0.94.0

package/es/json/nodes/JsonDocument.mjs

@@ -1,16 +1,9 @@
-import stampit from 'stampit';
 import { head } from 'ramda';
 import JsonNode from "./JsonNode.mjs";
-const JsonDocument = stampit(JsonNode, {
-  statics: {
-    type: 'document'
-  },
-  methods: {
-    // @ts-ignore
-    get child() {
-      // @ts-ignore
-      return head(this.children);
-    }
+class JsonDocument extends JsonNode {
+  static type = 'document';
+  get child() {
+    return head(this.children);
   }
-});
+}
 export default JsonDocument;

package/es/json/nodes/JsonEscapeSequence.mjs

@@ -1,8 +1,5 @@
-import stampit from 'stampit';
 import JsonValue from "./JsonValue.mjs";
-const JsonEscapeSequence = stampit(JsonValue, {
-  statics: {
-    type: 'escapeSequence'
-  }
-});
+class JsonEscapeSequence extends JsonValue {
+  static type = 'escapeSequence';
+}
 export default JsonEscapeSequence;

package/es/json/nodes/JsonFalse.mjs

@@ -1,8 +1,5 @@
-import stampit from 'stampit';
 import JsonValue from "./JsonValue.mjs";
-const JsonFalse = stampit(JsonValue, {
-  statics: {
-    type: 'false'
-  }
-});
+class JsonFalse extends JsonValue {
+  static type = 'false';
+}
 export default JsonFalse;

package/es/json/nodes/JsonKey.mjs

@@ -1,8 +1,5 @@
-import stampit from 'stampit';
 import JsonString from "./JsonString.mjs";
-const JsonKey = stampit(JsonString, {
-  statics: {
-    type: 'key'
-  }
-});
+class JsonKey extends JsonString {
+  static type = 'key';
+}
 export default JsonKey;

package/es/json/nodes/JsonNode.mjs

@@ -1,4 +1,3 @@
-import stampit from 'stampit';
 import Node from "../../Node.mjs";
-const JsonNode = stampit(Node);
+class JsonNode extends Node {}
 export default JsonNode;

package/es/json/nodes/JsonNull.mjs

@@ -1,8 +1,5 @@
-import stampit from 'stampit';
 import JsonValue from "./JsonValue.mjs";
-const JsonNull = stampit(JsonValue, {
-  statics: {
-    type: 'null'
-  }
-});
+class JsonNull extends JsonValue {
+  static type = 'null';
+}
 export default JsonNull;

package/es/json/nodes/JsonNumber.mjs

@@ -1,8 +1,5 @@
-import stampit from 'stampit';
 import JsonValue from "./JsonValue.mjs";
-const JsonNumber = stampit(JsonValue, {
-  statics: {
-    type: 'number'
-  }
-});
+class JsonNumber extends JsonValue {
+  static type = 'number';
+}
 export default JsonNumber;

package/es/json/nodes/JsonObject.mjs

@@ -1,15 +1,9 @@
-import stampit from 'stampit';
 import JsonNode from "./JsonNode.mjs";
 import { isProperty } from "./predicates.mjs";
-const JsonObject = stampit(JsonNode, {
-  statics: {
-    type: 'object'
-  },
-  methods: {
-    get properties() {
-      // @ts-ignore
-      return this.children.filter(isProperty);
-    }
+class JsonObject extends JsonNode {
+  static type = 'object';
+  get properties() {
+    return this.children.filter(isProperty);
   }
-});
+}
 export default JsonObject;

package/es/json/nodes/JsonProperty.mjs

@@ -1,21 +1,12 @@
-import stampit from 'stampit';
 import JsonNode from "./JsonNode.mjs";
 import { isArray, isFalse, isKey, isNull, isNumber, isObject, isString, isTrue } from "./predicates.mjs";
-const JsonProperty = stampit(JsonNode, {
-  statics: {
-    type: 'property'
-  },
-  methods: {
-    // @ts-ignore
-    get key() {
-      // @ts-ignore
-      return this.children.find(isKey);
-    },
-    // @ts-ignore
-    get value() {
-      // @ts-ignore
-      return this.children.find(node => isFalse(node) || isTrue(node) || isNull(node) || isNumber(node) || isString(node) || isArray(node) || isObject(node));
-    }
+class JsonProperty extends JsonNode {
+  static type = 'property';
+  get key() {
+    return this.children.find(isKey);
   }
-});
+  get value() {
+    return this.children.find(node => isFalse(node) || isTrue(node) || isNull(node) || isNumber(node) || isString(node) || isArray(node) || isObject(node));
+  }
+}
 export default JsonProperty;

package/es/json/nodes/JsonString.mjs

@@ -1,21 +1,13 @@
-import stampit from 'stampit';
 import JsonNode from "./JsonNode.mjs";
 import { isEscapeSequence, isStringContent } from "./predicates.mjs";
-const JsonString = stampit(JsonNode, {
-  statics: {
-    type: 'string'
-  },
-  methods: {
-    get value() {
-      // @ts-ignore
-      if (this.children.length === 1) {
-        // @ts-ignore
-        return this.children[0].value;
-      }
-      return this.children
-      // @ts-ignore
-      .filter(node => isStringContent(node) || isEscapeSequence(node)).reduce((acc, cur) => acc + cur.value, '');
+class JsonString extends JsonNode {
+  static type = 'string';
+  get value() {
+    if (this.children.length === 1) {
+      const onlyChild = this.children[0];
+      return onlyChild.value;
     }
+    return this.children.filter(node => isStringContent(node) || isEscapeSequence(node)).reduce((acc, cur) => acc + cur.value, '');
   }
-});
+}
 export default JsonString;

package/es/json/nodes/JsonStringContent.mjs

@@ -1,8 +1,5 @@
-import stampit from 'stampit';
 import JsonValue from "./JsonValue.mjs";
-const JsonStringContent = stampit(JsonValue, {
-  statics: {
-    type: 'stringContent'
-  }
-});
+class JsonStringContent extends JsonValue {
+  static type = 'stringContent';
+}
 export default JsonStringContent;

package/es/json/nodes/JsonTrue.mjs

@@ -1,8 +1,5 @@
-import stampit from 'stampit';
 import JsonValue from "./JsonValue.mjs";
-const JsonTrue = stampit(JsonValue, {
-  statics: {
-    type: 'true'
-  }
-});
+class JsonTrue extends JsonValue {
+  static type = 'true';
+}
 export default JsonTrue;

package/es/json/nodes/JsonValue.mjs

@@ -1,16 +1,15 @@
-import stampit from 'stampit';
 import JsonNode from "./JsonNode.mjs";
-const JsonValue = stampit(JsonNode, {
-  statics: {
-    type: 'value'
-  },
-  props: {
-    value: null
-  },
-  init({
-    value = null
-  } = {}) {
+class JsonValue extends JsonNode {
+  static type = 'value';
+  value;
+  constructor({
+    value,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
     this.value = value;
   }
-});
+}
 export default JsonValue;

package/es/json/nodes/predicates.mjs

@@ -1,13 +1,13 @@
 import { isNodeType } from "../../predicates.mjs";
-export const isDocument = isNodeType.bind(undefined, 'document');
-export const isString = isNodeType.bind(undefined, 'string');
-export const isFalse = isNodeType.bind(undefined, 'false');
-export const isTrue = isNodeType.bind(undefined, 'true');
-export const isNull = isNodeType.bind(undefined, 'null');
-export const isNumber = isNodeType.bind(undefined, 'number');
-export const isArray = isNodeType.bind(undefined, 'array');
-export const isObject = isNodeType.bind(undefined, 'object');
-export const isStringContent = isNodeType.bind(undefined, 'stringContent');
-export const isEscapeSequence = isNodeType.bind(undefined, 'escapeSequence');
-export const isProperty = isNodeType.bind(undefined, 'property');
-export const isKey = isNodeType.bind(undefined, 'key');
+export const isDocument = node => isNodeType('document', node);
+export const isString = node => isNodeType('string', node);
+export const isFalse = node => isNodeType('false', node);
+export const isTrue = node => isNodeType('true', node);
+export const isNull = node => isNodeType('null', node);
+export const isNumber = node => isNodeType('number', node);
+export const isArray = node => isNodeType('array', node);
+export const isObject = node => isNodeType('object', node);
+export const isStringContent = node => isNodeType('stringContent', node);
+export const isEscapeSequence = node => isNodeType('escapeSequence', node);
+export const isProperty = node => isNodeType('property', node);
+export const isKey = node => isNodeType('key', node);

package/es/predicates.mjs

@@ -1,5 +1,5 @@
-export const isNodeType = (type, node) => (node === null || node === void 0 ? void 0 : node.type) === type;
-export const isLiteral = isNodeType.bind(undefined, 'literal');
-export const isPosition = isNodeType.bind(undefined, 'position');
-export const isPoint = isNodeType.bind(undefined, 'point');
-export const isParseResult = isNodeType.bind(undefined, 'parseResult');
+export const isNodeType = (type, node) => node != null && typeof node === 'object' && 'type' in node && node.type === type;
+export const isLiteral = node => isNodeType('literal', node);
+export const isPosition = node => isNodeType('position', node);
+export const isPoint = node => isNodeType('point', node);
+export const isParseResult = node => isNodeType('parseResult', node);

package/es/yaml/anchors-aliases/ReferenceManager.mjs

@@ -0,0 +1,24 @@
+import YamlScalar from "../nodes/YamlScalar.mjs";
+import YamlReferenceError from "../errors/YamlReferenceError.mjs";
+import { isAnchor } from "../nodes/predicates.mjs";
+import { YamlStyle, YamlStyleGroup } from "../nodes/YamlStyle.mjs";
+/* eslint-disable class-methods-use-this */
+class ReferenceManager {
+  addAnchor(node) {
+    if (!isAnchor(node.anchor)) {
+      throw new YamlReferenceError('Expected YAML anchor to be attached the the YAML AST node.', {
+        node
+      });
+    }
+  }
+  resolveAlias(alias) {
+    return new YamlScalar({
+      content: alias.content,
+      style: YamlStyle.Plain,
+      styleGroup: YamlStyleGroup.Flow
+    });
+  }
+}
+/* eslint-enable class-methods-use-this */
+
+export default ReferenceManager;

package/es/yaml/errors/YamlError.mjs

@@ -0,0 +1,3 @@
+import { ApiDOMStructuredError } from '@swagger-api/apidom-error';
+class YamlError extends ApiDOMStructuredError {}
+export default YamlError;

package/es/yaml/errors/YamlReferenceError.mjs

@@ -0,0 +1,3 @@
+import YamlError from "./YamlError.mjs";
+class YamlReferenceError extends YamlError {}
+export default YamlReferenceError;

package/es/yaml/errors/YamlSchemaError.mjs

@@ -1,3 +1,3 @@
-import { ApiDOMStructuredError } from '@swagger-api/apidom-error';
-class YamlSchemaError extends ApiDOMStructuredError {}
+import YamlError from "./YamlError.mjs";
+class YamlSchemaError extends YamlError {}
 export default YamlSchemaError;

package/es/yaml/errors/YamlTagError.mjs

@@ -1,5 +1,11 @@
 import YamlSchemaError from "./YamlSchemaError.mjs";
 class YamlTagError extends YamlSchemaError {
+  specificTagName;
+  explicitTagName;
+  tagKind;
+  tagPosition;
+  nodeCanonicalContent;
+  node;
   constructor(message, structuredOptions) {
     super(message, structuredOptions);
     if (typeof structuredOptions !== 'undefined') {

package/es/yaml/nodes/YamlAlias.mjs

@@ -1,16 +1,15 @@
-import stampit from 'stampit';
 import Node from "../../Node.mjs";
-const YamlAlias = stampit(Node, {
-  statics: {
-    type: 'alias'
-  },
-  props: {
-    content: null
-  },
-  init({
-    content = null
-  } = {}) {
+class YamlAlias extends Node {
+  static type = 'alias';
+  content;
+  constructor({
+    content,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
     this.content = content;
   }
-});
+}
 export default YamlAlias;

package/es/yaml/nodes/YamlAnchor.mjs

@@ -1,16 +1,15 @@
-import stampit from 'stampit';
 import Node from "../../Node.mjs";
-const YamlAnchor = stampit(Node, {
-  statics: {
-    type: 'anchor'
-  },
-  props: {
-    name: null
-  },
-  init({
-    name = null
-  } = {}) {
+class YamlAnchor extends Node {
+  static type = 'anchor';
+  name;
+  constructor({
+    name,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
     this.name = name;
   }
-});
+}
 export default YamlAnchor;

package/es/yaml/nodes/YamlCollection.mjs

@@ -1,4 +1,3 @@
-import stampit from 'stampit';
 import YamlNode from "./YamlNode.mjs";
-const YamlCollection = stampit(YamlNode, {});
+class YamlCollection extends YamlNode {}
 export default YamlCollection;

package/es/yaml/nodes/YamlComment.mjs

@@ -1,16 +1,15 @@
-import stampit from 'stampit';
 import Node from "../../Node.mjs";
-const YamlComment = stampit(Node, {
-  statics: {
-    type: 'comment'
-  },
-  props: {
-    content: null
-  },
-  init({
-    content = null
-  } = {}) {
+class YamlComment extends Node {
+  static type = 'comment';
+  content;
+  constructor({
+    content,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
     this.content = content;
   }
-});
+}
 export default YamlComment;

package/es/yaml/nodes/YamlDirective.mjs

@@ -1,24 +1,23 @@
-import stampit from 'stampit';
 import { mergeRight } from 'ramda';
 import Node from "../../Node.mjs";
-const YamlDirective = stampit(Node, {
-  statics: {
-    type: 'directive'
-  },
-  props: {
-    name: null,
-    parameters: null
-  },
-  init({
-    name = null,
-    parameters = {}
-  } = {}) {
+class YamlDirective extends Node {
+  static type = 'directive';
+  name;
+  parameters;
+  constructor({
+    name,
+    parameters,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
     this.name = name;
     this.parameters = mergeRight({
-      version: null,
-      handle: null,
-      prefix: null
+      version: undefined,
+      handle: undefined,
+      prefix: undefined
     }, parameters);
   }
-});
+}
 export default YamlDirective;

package/es/yaml/nodes/YamlDocument.mjs

@@ -1,8 +1,5 @@
-import stampit from 'stampit';
 import Node from "../../Node.mjs";
-const YamlDocument = stampit(Node, {
-  statics: {
-    type: 'document'
-  }
-});
+class YamlDocument extends Node {
+  static type = 'document';
+}
 export default YamlDocument;

package/es/yaml/nodes/YamlKeyValuePair.mjs

@@ -1,34 +1,36 @@
-import stampit from 'stampit';
 import Node from "../../Node.mjs";
-import YamlStyleModel from "./YamlStyle.mjs";
 import { isScalar, isMapping, isSequence, isAlias } from "./predicates.mjs";
-const YamlKeyValuePair = stampit(Node, YamlStyleModel, {
-  statics: {
-    type: 'keyValuePair'
+class YamlKeyValuePair extends Node {
+  static type = 'keyValuePair';
+  styleGroup;
+  constructor({
+    styleGroup,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
+    this.styleGroup = styleGroup;
+  }
+}
+Object.defineProperties(YamlKeyValuePair.prototype, {
+  key: {
+    get() {
+      return this.children.filter(node => isScalar(node) || isMapping(node) || isSequence(node))[0];
+    },
+    enumerable: true
   },
-  propertyDescriptors: {
-    key: {
-      get() {
-        // @ts-ignore
-        return this.children.filter(node => isScalar(node) || isMapping(node) || isSequence(node))[0];
-      },
-      enumerable: true
+  value: {
+    get() {
+      const {
+        key,
+        children
+      } = this;
+      const excludeKeyPredicate = node => node !== key;
+      const valuePredicate = node => isScalar(node) || isMapping(node) || isSequence(node) || isAlias(node);
+      return children.filter(node => excludeKeyPredicate(node) && valuePredicate(node))[0];
     },
-    value: {
-      get() {
-        // @ts-ignore
-        const {
-          key,
-          children
-        } = this;
-        const excludeKeyPredicate = node => node !== key;
-        const valuePredicate = node => isScalar(node) || isMapping(node) || isSequence(node) || isAlias(node);
-
-        // @ts-ignore
-        return children.filter(node => excludeKeyPredicate(node) && valuePredicate(node))[0];
-      },
-      enumerable: true
-    }
+    enumerable: true
   }
 });
 export default YamlKeyValuePair;

package/es/yaml/nodes/YamlMapping.mjs

@@ -1,18 +1,12 @@
-import stampit from 'stampit';
 import YamlCollection from "./YamlCollection.mjs";
 import { isKeyValuePair } from "./predicates.mjs";
-const YamlMapping = stampit(YamlCollection, {
-  statics: {
-    type: 'mapping'
+class YamlMapping extends YamlCollection {
+  static type = 'mapping';
+}
+Object.defineProperty(YamlMapping.prototype, 'content', {
+  get() {
+    return Array.isArray(this.children) ? this.children.filter(isKeyValuePair) : [];
   },
-  propertyDescriptors: {
-    content: {
-      get() {
-        // @ts-ignore
-        return Array.isArray(this.children) ? this.children.filter(isKeyValuePair) : [];
-      },
-      enumerable: true
-    }
-  }
+  enumerable: true
 });
 export default YamlMapping;

package/es/yaml/nodes/YamlNode.mjs

@@ -1,22 +1,23 @@
-import stampit from 'stampit';
 import Node from "../../Node.mjs";
-const YamlNode = stampit(Node, {
-  props: {
-    anchor: null,
-    tag: null,
-    style: null,
-    styleGroup: null
-  },
-  init({
-    anchor = null,
-    tag = null,
-    style = null,
-    styleGroup = null
-  } = {}) {
+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/es/yaml/nodes/YamlScalar.mjs

@@ -1,16 +1,15 @@
-import stampit from 'stampit';
 import YamlNode from "./YamlNode.mjs";
-const YamlScalar = stampit(YamlNode, {
-  statics: {
-    type: 'scalar'
-  },
-  props: {
-    content: ''
-  },
-  init({
-    content
-  } = {}) {
+class YamlScalar extends YamlNode {
+  static type = 'scalar';
+  content;
+  constructor({
+    content,
+    ...rest
+  }) {
+    super({
+      ...rest
+    });
     this.content = content;
   }
-});
+}
 export default YamlScalar;