@swagger-api/apidom-parser-adapter-yaml-1-2 0.68.1

package/es/syntactic-analysis/visitors/YamlAstVisitor.js

@@ -0,0 +1,171 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+import stampit from 'stampit';
+import { getNodeType as getCSTNodeType, isNode as isCSTNode, YamlStyle } from '@swagger-api/apidom-ast';
+import { ParseResultElement, AnnotationElement, CommentElement, SourceMapElement, MemberElement, ObjectElement, ArrayElement, isPrimitiveElement, isElement, keyMap as keyMapApiDOM, getNodeType as getNodeTypeApiDOM, createNamespace } from '@swagger-api/apidom-core';
+export const keyMap = _objectSpread({
+  stream: ['children'],
+  document: ['children'],
+  mapping: ['children'],
+  keyValuePair: ['children'],
+  sequence: ['children'],
+  error: ['children']
+}, keyMapApiDOM);
+export const getNodeType = node => {
+  if (isElement(node)) {
+    return getNodeTypeApiDOM(node);
+  }
+  return getCSTNodeType(node);
+};
+export const isNode = node => isElement(node) || isCSTNode(node) || Array.isArray(node);
+
+/* eslint-disable no-underscore-dangle */
+
+const YamlAstVisitor = stampit({
+  props: {
+    sourceMap: false,
+    processedDocumentCount: 0,
+    annotations: [],
+    namespace: null
+  },
+  init() {
+    /**
+     * Private API.
+     */
+
+    const maybeAddSourceMap = (node, element) => {
+      if (!this.sourceMap) {
+        return;
+      }
+      const sourceMap = new SourceMapElement();
+      // @ts-ignore
+      sourceMap.position = node.position;
+      // @ts-ignore
+      sourceMap.astNode = node;
+      element.meta.set('sourceMap', sourceMap);
+    };
+
+    /**
+     * Public API.
+     */
+
+    this.namespace = createNamespace();
+    this.annotations = [];
+    this.stream = {
+      leave(node) {
+        const element = new ParseResultElement();
+        // @ts-ignore
+        element._content = node.children.flat(1);
+
+        // mark first-non Annotation element as result
+        // @ts-ignore
+        const elements = element.findElements(isPrimitiveElement);
+        if (elements.length > 0) {
+          const resultElement = elements[0];
+          resultElement.classes.push('result');
+        }
+
+        // provide annotations
+        this.annotations.forEach(annotationElement => {
+          element.push(annotationElement);
+        });
+        this.annotations = [];
+        return element;
+      }
+    };
+    this.comment = function comment(node) {
+      const isStreamComment = this.processedDocumentCount === 0;
+
+      // we're only interested of stream comments before the first document
+      if (isStreamComment) {
+        // @ts-ignore
+        const element = new CommentElement(node.content);
+        maybeAddSourceMap(node, element);
+        return element;
+      }
+      return null;
+    };
+    this.document = function document(node) {
+      const shouldWarnAboutMoreDocuments = this.processedDocumentCount === 1;
+      const shouldSkipVisitingMoreDocuments = this.processedDocumentCount >= 1;
+      if (shouldWarnAboutMoreDocuments) {
+        const message = 'Only first document within YAML stream will be used. Rest will be discarded.';
+        const element = new AnnotationElement(message);
+        element.classes.push('warning');
+        maybeAddSourceMap(node, element);
+        this.annotations.push(element);
+      }
+      if (shouldSkipVisitingMoreDocuments) {
+        return null;
+      }
+      this.processedDocumentCount += 1;
+      return node.children;
+    };
+    this.mapping = function mapping(node) {
+      const element = new ObjectElement();
+      // @ts-ignore
+      element._content = node.children;
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.keyValuePair = function keyValuePair(node) {
+      const element = new MemberElement();
+
+      // @ts-ignore
+      element.content.key = node.key;
+      // @ts-ignore
+      element.content.value = node.value;
+      maybeAddSourceMap(node, element);
+
+      // process possible errors here that may be present in property node children as we're using direct field access
+      node.children.filter(child => child.type === 'error').forEach(errorNode => {
+        this.error(errorNode, node, [], [node]);
+      });
+      return element;
+    };
+    this.sequence = function sequence(node) {
+      const element = new ArrayElement();
+      // @ts-ignore
+      element._content = node.children;
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.scalar = function scalar(node) {
+      const element = this.namespace.toElement(node.content);
+
+      // translate style information about empty nodes
+      if (node.content === '' && node.style === YamlStyle.Plain) {
+        element.classes.push('yaml-e-node');
+        element.classes.push('yaml-e-scalar');
+      }
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.literal = function literal(node) {
+      if (node.isMissing) {
+        const message = `(Missing ${node.value})`;
+        const element = new AnnotationElement(message);
+        element.classes.push('warning');
+        maybeAddSourceMap(node, element);
+        this.annotations.push(element);
+      }
+      return null;
+    };
+    this.error = function error(node, key, parent, path) {
+      const message = node.isUnexpected ? `(Unexpected ${node.value})` : `(Error ${node.value})`;
+      const element = new AnnotationElement(message);
+      element.classes.push('error');
+      maybeAddSourceMap(node, element);
+      if (path.length === 0) {
+        // no document to visit, only error is present in CST
+        const parseResultElement = new ParseResultElement();
+        parseResultElement.push(element);
+        return parseResultElement;
+      }
+      this.annotations.push(element);
+      return null;
+    };
+  }
+});
+export default YamlAstVisitor;

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@swagger-api/apidom-parser-adapter-yaml-1-2",
+  "version": "0.68.1",
+  "description": "Parser adapter for parsing YAML documents into base namespace.",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "type": "module",
+  "sideEffects": [
+    "./es/lexical-analysis/browser-patch.js",
+    "./cjs/lexical-analysis/browser-patch.cjs"
+  ],
+  "unpkg": "./dist/apidom-parser-apdater-yaml-1-2.browser.min.js",
+  "main": "./cjs/adapter-node.cjs",
+  "exports": {
+    "types": "./types/dist.d.ts",
+    "node": {
+      "import": "./es/adapter-node.js",
+      "require": "./cjs/adapter-node.cjs"
+    },
+    "browser": {
+      "import": "./es/adapter-browser.js"
+    },
+    "default": "./cjs/adapter-node.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": "npm run build:wasm && npm run build:wasm:copy && cross-env BABEL_ENV=es babel src --out-dir es --extensions '.ts' --root-mode 'upward'",
+    "build:cjs": "npm run build:wasm && npm run build:wasm:copy && BABEL_ENV=cjs babel src --out-dir cjs --extensions '.ts' --out-file-extension '.cjs' --root-mode 'upward'",
+    "build:umd:browser": "npm run build:wasm && npm run build:wasm:copy && cross-env BABEL_ENV=browser BROWSERSLIST_ENV=production webpack --config config/webpack/browser.config.js --progress",
+    "build:wasm": "node ../../scripts/file-exists.js ../../node_modules/tree-sitter-yaml/tree-sitter-yaml.wasm && exit 0 || cd ../../node_modules/tree-sitter-yaml && cross-env BABEL_ENV=cjs NODE_OPTIONS='-r core-js/stable @babel/register' tree-sitter generate --abi=13 ./grammar.js && tree-sitter build-wasm && node-gyp rebuild",
+    "build:wasm:copy": "copyfiles -u 4 ../../node_modules/tree-sitter-yaml/tree-sitter-yaml.wasm wasm",
+    "lint": "eslint ./",
+    "lint:fix": "eslint ./ --fix",
+    "clean": "rimraf ./es ./cjs ./dist ./types",
+    "typescript:check-types": "tsc --noEmit",
+    "typescript:declaration": "tsc -p declaration.tsconfig.json && rollup -c config/rollup/types.dist.js",
+    "test": "cross-env NODE_ENV=test BABEL_ENV=cjs mocha",
+    "perf": "cross-env NODE_ENV=test BABEL_ENV=cjs node ./test/perf/index.cjs",
+    "perf:parse": "cross-env NODE_ENV=test BABEL_ENV=cjs node ./test/perf/parse.cjs",
+    "perf:lexical-analysis": "cross-env NODE_ENV=test BABEL_ENV=cjs node ./test/perf/lexical-analysis.cjs",
+    "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",
+  "dependencies": {
+    "@babel/runtime-corejs3": "^7.20.7",
+    "@swagger-api/apidom-ast": "^0.68.0",
+    "@swagger-api/apidom-core": "^0.68.1",
+    "@types/ramda": "=0.28.23",
+    "ramda": "=0.28.0",
+    "ramda-adjunct": "=3.4.0",
+    "stampit": "=4.3.2",
+    "tree-sitter": "=0.20.1",
+    "tree-sitter-yaml": "=0.5.0",
+    "web-tree-sitter": "=0.20.7"
+  },
+  "devDependencies": {
+    "tree-sitter-cli": "=0.20.7"
+  },
+  "files": [
+    "cjs/",
+    "dist/",
+    "es/",
+    "types/dist.d.ts",
+    "wasm/",
+    "LICENSES",
+    "NOTICE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "gitHead": "d2bc706671f1b9a593b8f0c5bca8c501ad0e4cff"
+}

package/types/dist.d.ts

@@ -0,0 +1,39 @@
+import * as _swagger_api_apidom_core from '@swagger-api/apidom-core';
+import { ParseResultElement, MediaTypes } from '@swagger-api/apidom-core';
+import { Tree as Tree$1 } from 'web-tree-sitter';
+import { Tree as Tree$2 } from 'tree-sitter';
+
+/**
+ * Lexical Analysis of source string using WebTreeSitter.
+ * This is WebAssembly version of TreeSitters Lexical Analysis.
+ *
+ * Given JavaScript doesn't support true parallelism, this
+ * code should be as lazy as possible and temporal safety should be fine.
+ */
+declare const analyze$1: (source: string) => Promise<Tree$1>;
+
+type Tree = Tree$1 | Tree$2;
+/**
+ * This version of syntactic analysis does following transformations:
+ *   TreeSitter CST -> YAML AST -> ApiDOM
+ * Two traversals passes are needed to get from CST to ApiDOM.
+ */
+declare const analyze: (cst: Tree, { sourceMap }?: {
+    sourceMap?: boolean | undefined;
+}) => ParseResultElement;
+
+declare class YamlMediaTypes extends MediaTypes<string> {
+    latest(): string;
+}
+declare const mediaTypes: YamlMediaTypes;
+
+declare const namespace: _swagger_api_apidom_core.Namespace;
+
+declare const detect: (source: string) => Promise<boolean>;
+interface ParseFunctionOptions {
+    sourceMap?: boolean;
+}
+type ParseFunction = (source: string, options?: ParseFunctionOptions) => Promise<ParseResultElement>;
+declare const parse: ParseFunction;
+
+export { detect, analyze$1 as lexicalAnalysis, mediaTypes, namespace, parse, analyze as syntacticAnalysis };