@swagger-api/apidom-ast 0.68.0

package/es/yaml/nodes/YamlStream.js

@@ -0,0 +1,20 @@
+import stampit from 'stampit';
+import Node from "../../Node.js";
+import { isComment, isDocument } from "./predicates.js";
+const YamlStream = stampit(Node, {
+  statics: {
+    type: 'stream'
+  },
+  propertyDescriptors: {
+    content: {
+      get() {
+        // @ts-ignore
+        return Array.isArray(this.children) ?
+        // @ts-ignore
+        this.children.filter(node => isDocument(node) || isComment(node)) : [];
+      },
+      enumerable: true
+    }
+  }
+});
+export default YamlStream;

package/es/yaml/nodes/YamlStyle.js

@@ -0,0 +1,25 @@
+import stampit from 'stampit';
+export let YamlStyle;
+(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";
+})(YamlStyle || (YamlStyle = {}));
+export let YamlStyleGroup;
+(function (YamlStyleGroup) {
+  YamlStyleGroup["Flow"] = "Flow";
+  YamlStyleGroup["Block"] = "Block";
+})(YamlStyleGroup || (YamlStyleGroup = {}));
+const YamlStyleModel = stampit({
+  props: {
+    styleGroup: null,
+    style: null
+  }
+});
+export default YamlStyleModel;

package/es/yaml/nodes/YamlTag.js

@@ -0,0 +1,25 @@
+import stampit from 'stampit';
+import Node from "../../Node.js";
+export let YamlNodeKind;
+(function (YamlNodeKind) {
+  YamlNodeKind["Scalar"] = "Scalar";
+  YamlNodeKind["Sequence"] = "Sequence";
+  YamlNodeKind["Mapping"] = "Mapping";
+})(YamlNodeKind || (YamlNodeKind = {}));
+const YamlTag = stampit(Node, {
+  statics: {
+    type: 'tag'
+  },
+  props: {
+    explicitName: '',
+    kind: null
+  },
+  init({
+    explicitName,
+    kind
+  } = {}) {
+    this.explicitName = explicitName;
+    this.kind = kind;
+  }
+});
+export default YamlTag;

package/es/yaml/nodes/predicates.js

@@ -0,0 +1,11 @@
+import { isNodeType } from "../../predicates.js";
+export const isStream = isNodeType.bind(undefined, 'stream');
+export const isDocument = isNodeType.bind(undefined, 'document');
+export const isMapping = isNodeType.bind(undefined, 'mapping');
+export const isSequence = isNodeType.bind(undefined, 'sequence');
+export const isKeyValuePair = isNodeType.bind(undefined, 'keyValuePair');
+export const isTag = isNodeType.bind(undefined, 'tag');
+export const isScalar = isNodeType.bind(undefined, 'scalar');
+export const isAlias = isNodeType.bind(undefined, 'alias');
+export const isDirective = isNodeType.bind(undefined, 'directive');
+export const isComment = isNodeType.bind(undefined, 'comment');

package/es/yaml/schemas/ScalarTag.js

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

package/es/yaml/schemas/Tag.js

@@ -0,0 +1,8 @@
+import stampit from 'stampit';
+import ScalarTag from "./ScalarTag.js";
+const Tag = stampit(ScalarTag, {
+  props: {
+    tag: ''
+  }
+});
+export default Tag;

package/es/yaml/schemas/canonical-format.js

@@ -0,0 +1,122 @@
+import { tail, compose, pathOr, map, concat, transduce, pipe, trim, split, join, curry } from 'ramda';
+import { isInteger, trimStart, trimEnd, isUndefined, trimCharsStart, isEmptyString, repeatStr, concatRight } from 'ramda-adjunct';
+import { unraw } from 'unraw';
+
+/**
+ * Helpers.
+ */
+
+const blockStyleRegExp = /^(?<style>[|>])(?<chomping>[+-]?)(?<indentation>[0-9]*)\s/;
+const getIndentationIndicator = content => {
+  const matches = content.match(blockStyleRegExp);
+  const indicator = pathOr('', ['groups', 'indentation'], matches);
+  return isEmptyString(indicator) ? undefined : parseInt(indicator, 10);
+};
+const getIndentation = content => {
+  const explicitIndentationIndicator = getIndentationIndicator(content);
+
+  // we have explicit indentation indicator
+  if (isInteger(explicitIndentationIndicator)) {
+    return repeatStr(' ', explicitIndentationIndicator);
+  }
+
+  // we assume indentation indicator from first line
+  const firstLine = pathOr('', [1], content.split('\n'));
+  const implicitIndentationIndicator = pathOr(0, ['groups', 'indentation', 'length'], firstLine.match(/^(?<indentation>[ ]*)/));
+  return repeatStr(' ', implicitIndentationIndicator);
+};
+const getChompingIndicator = content => {
+  const matches = content.match(blockStyleRegExp);
+  const indicator = pathOr('', ['groups', 'chomping'], matches);
+  return isEmptyString(indicator) ? undefined : indicator;
+};
+const chomp = (indicator, content) => {
+  // clip (single newline at end)
+  if (isUndefined(indicator)) {
+    return `${trimEnd(content)}\n`;
+  }
+  // strip (no newline at end)
+  if (indicator === '-') {
+    return 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 = 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
+ */
+export const formatFlowPlain = pipe(normalizeLineBreaks, trim, collapseLineBreakToSpace, split('\n'), map(trimStart), join('\n'));
+
+/**
+ * Formats Flow Scalar Single-Quoted style.
+ * https://yaml.org/spec/1.2/spec.html#id2788097
+ */
+
+export const formatFlowSingleQuoted = pipe(normalizeLineBreaks, trim, removeQuotes("'"), collapseLineBreakToSpace, split('\n'), map(trimStart), join('\n'));
+
+/**
+ * Formats Flow Scalar Double-Quoted style.
+ * https://yaml.org/spec/1.2/spec.html#id2787109
+ */
+export const formatFlowDoubleQuoted = pipe(normalizeLineBreaks, trim, removeQuotes('"'), preventLineBreakCollapseToSpace, collapseLineBreakToSpace, unraw, split('\n'), map(trimStart), join('\n'));
+
+/**
+ * Formats Block Scalar Literal style.
+ * https://yaml.org/spec/1.2/spec.html#id2795688
+ */
+export const formatBlockLiteral = content => {
+  const indentation = getIndentation(content);
+  const chompingIndicator = getChompingIndicator(content);
+  const normalized = normalizeLineBreaks(content);
+  const lines = tail(normalized.split('\n')); // first line only contains indicators
+  const transducer = compose(map(trimCharsStart(indentation)), map(concatRight('\n')));
+  // @ts-ignore
+  const deindented = transduce(transducer, concat, '', lines);
+  return chomp(chompingIndicator, deindented);
+};
+
+/**
+ * Formats BLock Scalar Folded style.
+ * https://yaml.org/spec/1.2/spec.html#id2796251
+ */
+export const formatBlockFolded = content => {
+  const indentation = getIndentation(content);
+  const chompingIndicator = getChompingIndicator(content);
+  const normalized = normalizeLineBreaks(content);
+  const lines = tail(normalized.split('\n')); // first line only contains indicators
+  const transducer = compose(map(trimCharsStart(indentation)), map(concatRight('\n')));
+  // @ts-ignore
+  const deindented = transduce(transducer, concat, '', lines);
+  const collapsed = collapseLineBreakToSpace(deindented);
+  return chomp(chompingIndicator, collapsed);
+};

package/es/yaml/schemas/failsafe/GenericMapping.js

@@ -0,0 +1,23 @@
+import stampit from 'stampit';
+import Tag from "../Tag.js";
+import { YamlNodeKind } from "../../nodes/YamlTag.js";
+const GenericMapping = stampit(Tag, {
+  statics: {
+    uri: 'tag:yaml.org,2002:map'
+  },
+  init(args, {
+    stamp
+  }) {
+    this.tag = stamp.uri;
+  },
+  methods: {
+    test(node) {
+      // @ts-ignore
+      return node.tag.kind === YamlNodeKind.Mapping;
+    },
+    resolve(node) {
+      return node;
+    }
+  }
+});
+export default GenericMapping;

package/es/yaml/schemas/failsafe/GenericSequence.js

@@ -0,0 +1,23 @@
+import stampit from 'stampit';
+import Tag from "../Tag.js";
+import { YamlNodeKind } from "../../nodes/YamlTag.js";
+const GenericSequence = stampit(Tag, {
+  statics: {
+    uri: 'tag:yaml.org,2002:seq'
+  },
+  init(args, {
+    stamp
+  }) {
+    this.tag = stamp.uri;
+  },
+  methods: {
+    test(node) {
+      // @ts-ignore
+      return node.tag.kind === YamlNodeKind.Sequence;
+    },
+    resolve(node) {
+      return node;
+    }
+  }
+});
+export default GenericSequence;

package/es/yaml/schemas/failsafe/GenericString.js

@@ -0,0 +1,18 @@
+import stampit from 'stampit';
+import Tag from "../Tag.js";
+const GenericString = stampit(Tag, {
+  statics: {
+    uri: 'tag:yaml.org,2002:str'
+  },
+  init(args, {
+    stamp
+  }) {
+    this.tag = stamp.uri;
+  },
+  methods: {
+    resolve(node) {
+      return node;
+    }
+  }
+});
+export default GenericString;

package/es/yaml/schemas/failsafe/index.js

@@ -0,0 +1,90 @@
+import stampit from 'stampit';
+import { YamlNodeKind } from "../../nodes/YamlTag.js";
+import GenericMapping from "./GenericMapping.js";
+import GenericSequence from "./GenericSequence.js";
+import GenericString from "./GenericString.js";
+import ScalarTag from "../ScalarTag.js";
+const FailsafeSchema = stampit({
+  props: {
+    tags: [],
+    tagDirectives: []
+  },
+  init() {
+    this.tags = [];
+    this.tagDirectives = [];
+    this.registerTag(GenericMapping());
+    this.registerTag(GenericSequence());
+    this.registerTag(GenericString());
+  },
+  methods: {
+    toSpecificTagName(node) {
+      let specificTagName = node.tag.explicitName;
+      if (node.tag.explicitName === '!') {
+        // non-specific tag; we assume tag by kind
+        if (node.tag.kind === YamlNodeKind.Scalar) {
+          // @ts-ignore
+          specificTagName = GenericString.uri;
+        } else if (node.tag.kind === YamlNodeKind.Sequence) {
+          // @ts-ignore
+          specificTagName = GenericSequence.uri;
+        } else if (node.tag.kind === YamlNodeKind.Mapping) {
+          // @ts-ignore
+          specificTagName = GenericMapping.uri;
+        }
+      } else if (node.tag.explicitName.startsWith('!<')) {
+        // verbatim form
+        specificTagName = node.tag.explicitName.replace(/^!</, '').replace(/>$/, '');
+      } else if (node.tag.explicitName.startsWith('!!')) {
+        // shorthand notation
+        specificTagName = `tag:yaml.org,2002:${node.tag.explicitName.replace(/^!!/, '')}`;
+      }
+      return specificTagName;
+    },
+    registerTagDirective(tagDirective) {
+      this.tagDirectives.push({
+        handle: tagDirective.parameters.handle,
+        prefix: tagDirective.parameters.prefix
+      });
+    },
+    registerTag(tag, beginning = false) {
+      if (beginning) {
+        this.tags.unshift(tag);
+      } else {
+        this.tags.push(tag);
+      }
+      return this;
+    },
+    overrideTag(tag) {
+      this.tags = this.tags.filter(itag => itag.tag === tag.tag);
+      this.tags.push(tag);
+      return this;
+    },
+    resolve(node) {
+      const specificTagName = this.toSpecificTagName(node);
+
+      // leave this node unresolved
+      if (specificTagName === '?') {
+        return node;
+      }
+
+      // turn scalar nodes into canonical format before resolving
+      let canonicalNode = node;
+      if (node.tag.kind === YamlNodeKind.Scalar) {
+        canonicalNode = ScalarTag().canonicalFormat(node);
+      }
+      const tag = this.tags.find(itag => (itag === null || itag === void 0 ? void 0 : itag.tag) === specificTagName);
+
+      // mechanism for resolving node (tag implementation) not found
+      if (typeof tag === 'undefined') {
+        throw new Error(`Tag "${specificTagName}" couldn't be resolved`);
+      }
+
+      // node content is not compatible with resolving mechanism (tag implementation)
+      if (!tag.test(canonicalNode)) {
+        throw new Error(`Node couldn't be resolved against tag "${specificTagName}"`);
+      }
+      return tag.resolve(canonicalNode);
+    }
+  }
+});
+export default FailsafeSchema;

package/es/yaml/schemas/json/Boolean.js

@@ -0,0 +1,24 @@
+import stampit from 'stampit';
+import Tag from "../Tag.js";
+const Boolean = stampit(Tag, {
+  statics: {
+    uri: 'tag:yaml.org,2002:bool'
+  },
+  init(args, {
+    stamp
+  }) {
+    this.tag = stamp.uri;
+  },
+  methods: {
+    test(node) {
+      return /^(true|false)$/.test(node.content);
+    },
+    resolve(node) {
+      const content = node.content === 'true';
+      const nodeClone = node.clone();
+      nodeClone.content = content;
+      return nodeClone;
+    }
+  }
+});
+export default Boolean;

package/es/yaml/schemas/json/FloatingPoint.js

@@ -0,0 +1,24 @@
+import stampit from 'stampit';
+import Tag from "../Tag.js";
+const FloatingPoint = stampit(Tag, {
+  statics: {
+    uri: 'tag:yaml.org,2002:float'
+  },
+  init(args, {
+    stamp
+  }) {
+    this.tag = stamp.uri;
+  },
+  methods: {
+    test(node) {
+      return /^-?(0|[1-9][0-9]*)(\.[0-9]*)?([eE][-+]?[0-9]+)?$/.test(node.content);
+    },
+    resolve(node) {
+      const content = parseFloat(node.content);
+      const nodeClone = node.clone();
+      nodeClone.content = content;
+      return nodeClone;
+    }
+  }
+});
+export default FloatingPoint;

package/es/yaml/schemas/json/Integer.js

@@ -0,0 +1,24 @@
+import stampit from 'stampit';
+import Tag from "../Tag.js";
+const Integer = stampit(Tag, {
+  statics: {
+    uri: 'tag:yaml.org,2002:int'
+  },
+  init(args, {
+    stamp
+  }) {
+    this.tag = stamp.uri;
+  },
+  methods: {
+    test(node) {
+      return /^-?(0|[1-9][0-9]*)$/.test(node.content);
+    },
+    resolve(node) {
+      const content = parseInt(node.content, 10);
+      const nodeClone = node.clone();
+      nodeClone.content = content;
+      return nodeClone;
+    }
+  }
+});
+export default Integer;

package/es/yaml/schemas/json/Null.js

@@ -0,0 +1,23 @@
+import stampit from 'stampit';
+import Tag from "../Tag.js";
+const Null = stampit(Tag, {
+  statics: {
+    uri: 'tag:yaml.org,2002:null'
+  },
+  init(args, {
+    stamp
+  }) {
+    this.tag = stamp.uri;
+  },
+  methods: {
+    test(node) {
+      return /^null$/.test(node.content);
+    },
+    resolve(node) {
+      const nodeClone = node.clone();
+      nodeClone.content = null;
+      return nodeClone;
+    }
+  }
+});
+export default Null;

package/es/yaml/schemas/json/index.js

@@ -0,0 +1,41 @@
+import stampit from 'stampit';
+import FailsafeSchema from "../failsafe/index.js";
+import Boolean from "./Boolean.js";
+import FloatingPoint from "./FloatingPoint.js";
+import Integer from "./Integer.js";
+import Null from "./Null.js";
+import { YamlNodeKind } from "../../nodes/YamlTag.js";
+import GenericSequence from "../failsafe/GenericSequence.js";
+import GenericMapping from "../failsafe/GenericMapping.js";
+const JsonSchema = stampit(FailsafeSchema, {
+  init() {
+    /**
+     * We're registering more specific tags before more generic ones from Failsafe schema.
+     */
+    this.registerTag(Boolean(), true);
+    this.registerTag(FloatingPoint(), true);
+    this.registerTag(Integer(), true);
+    this.registerTag(Null(), true);
+  },
+  methods: {
+    toSpecificTagName(node) {
+      // @ts-ignore
+      let specificTagName = FailsafeSchema.compose.methods.toSpecificTagName.call(this, node);
+      if (specificTagName === '?') {
+        if (node.tag.vkind === YamlNodeKind.Sequence) {
+          // @ts-ignore
+          specificTagName = GenericSequence.uri;
+        } else if (node.tag.kind === YamlNodeKind.Mapping) {
+          // @ts-ignore
+          specificTagName = GenericMapping.uri;
+        } else if (node.tag.kind === YamlNodeKind.Scalar) {
+          // @ts-ignore
+          const foundTag = this.tags.find(tag => tag.test(node));
+          specificTagName = (foundTag === null || foundTag === void 0 ? void 0 : foundTag.tag) || '?';
+        }
+      }
+      return specificTagName;
+    }
+  }
+});
+export default JsonSchema;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@swagger-api/apidom-ast",
+  "version": "0.68.0",
+  "description": "Tools necessary for parsing stage of ApiDOM, specifically for syntactic analysis.",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "unpkg": "./dist/apidom.ast.min.js",
+  "main": "./cjs/index.cjs",
+  "exports": {
+    "types": "./types/dist.d.ts",
+    "import": "./es/index.js",
+    "require": "./cjs/index.cjs"
+  },
+  "types": "./types/dist.d.ts",
+  "scripts": {
+    "build": "npm run clean && run-p --max-parallel ${CPU_CORES:-2} typescript:declaration build:es build:cjs build:umd:browser",
+    "build:es": "cross-env BABEL_ENV=es babel src --out-dir es --extensions '.ts' --root-mode 'upward'",
+    "build:cjs": "cross-env BABEL_ENV=cjs babel src --out-dir cjs --extensions '.ts' --out-file-extension '.cjs' --root-mode 'upward'",
+    "build:umd:browser": "cross-env BABEL_ENV=browser BROWSERSLIST_ENV=production webpack --config config/webpack/browser.config.js --progress",
+    "lint": "eslint ./",
+    "lint:fix": "eslint ./ --fix",
+    "clean": "rimraf ./es ./cjs ./dist ./types",
+    "test": "cross-env NODE_ENV=test BABEL_ENV=cjs mocha",
+    "typescript:check-types": "tsc --noEmit",
+    "typescript:declaration": "tsc -p declaration.tsconfig.json && rollup -c config/rollup/types.dist.js",
+    "prepack": "copyfiles -u 3 ../../LICENSES/* LICENSES && copyfiles -u 2 ../../NOTICE .",
+    "postpack": "rimraf NOTICE LICENSES"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/swagger-api/apidom.git"
+  },
+  "author": "Vladimir Gorej",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/swagger-api/apidom/issues"
+  },
+  "homepage": "https://github.com/swagger-api/apidom#readme",
+  "dependencies": {
+    "@babel/runtime-corejs3": "^7.20.7",
+    "@types/ramda": "=0.28.23",
+    "ramda": "=0.28.0",
+    "ramda-adjunct": "=3.4.0",
+    "stampit": "=4.3.2",
+    "unraw": "=2.0.1"
+  },
+  "files": [
+    "cjs/",
+    "dist/",
+    "es/",
+    "types/dist.d.ts",
+    "LICENSES",
+    "NOTICE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "gitHead": "d2bc706671f1b9a593b8f0c5bca8c501ad0e4cff"
+}