@swagger-api/apidom-parser-adapter-json 0.68.1

package/es/syntactic-analysis/indirect/visitors/JsonAstVisitor.js

@@ -0,0 +1,180 @@
+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 { JsonArray, JsonDocument, JsonObject, JsonProperty, ParseResult, Error, isNode as isCSTNode, getNodeType as getCSTNodeType } from '@swagger-api/apidom-ast';
+import { ParseResultElement, ObjectElement, SourceMapElement, MemberElement, ArrayElement, BooleanElement, NullElement, NumberElement, StringElement, AnnotationElement, isParseResultElement, isPrimitiveElement, isElement, keyMap as keyMapApiDOM, getNodeType as getNodeTypeApiDOM } from '@swagger-api/apidom-core';
+export const keyMap = _objectSpread({
+  // @ts-ignore
+  [ParseResult.type]: ['children'],
+  // @ts-ignore
+  [JsonDocument.type]: ['children'],
+  // @ts-ignore
+  [JsonObject.type]: ['children'],
+  // @ts-ignore
+  [JsonProperty.type]: ['children'],
+  // @ts-ignore
+  [JsonArray.type]: ['children'],
+  // @ts-ignore
+  [Error.type]: ['children']
+}, keyMapApiDOM);
+export const getNodeType = node => {
+  if (isParseResultElement(node)) {
+    return 'ParseResultElement';
+  }
+  if (isElement(node)) {
+    return getNodeTypeApiDOM(node);
+  }
+  return getCSTNodeType(node);
+};
+export const isNode = element => isElement(element) || isCSTNode(element);
+
+/* eslint-disable no-underscore-dangle */
+
+const JsonAstVisitor = stampit({
+  props: {
+    sourceMap: false,
+    annotations: []
+  },
+  init() {
+    /**
+     * Private API.
+     */
+
+    this.annotation = [];
+    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.document = function document(node) {
+      const element = new ParseResultElement();
+      // @ts-ignore
+      element._content = node.children;
+      return element;
+    };
+    this.ParseResultElement = {
+      leave(element) {
+        // 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 = [];
+      }
+    };
+    this.object = function object(node) {
+      const element = new ObjectElement();
+      // @ts-ignore
+      element._content = node.children;
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.property = function property(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 pair node children as we're using direct field access.
+       * There are usually 3 children here found: "key", ":", "value".
+       */
+      if (node.children.length > 3) {
+        node.children.filter(child => child.type === 'error').forEach(errorNode => {
+          this.error(errorNode, node, [], [node]);
+        });
+      }
+      return element;
+    };
+    this.key = function key(node) {
+      const element = new StringElement(node.value);
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.array = function array(node) {
+      const element = new ArrayElement();
+      // @ts-ignore
+      element._content = node.children;
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.string = function string(node) {
+      const element = new StringElement(node.value);
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+    this.number = function number(node) {
+      const element = new NumberElement(Number(node.value));
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    this.null = function _null(node) {
+      const element = new NullElement();
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    this.true = function _true(node) {
+      const element = new BooleanElement(true);
+      maybeAddSourceMap(node, element);
+      return element;
+    };
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    this.false = function _false(node) {
+      const element = new BooleanElement(false);
+      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 JsonAstVisitor;

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@swagger-api/apidom-parser-adapter-json",
+  "version": "0.68.1",
+  "description": "Parser adapter for parsing JSON 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-json.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-json/tree-sitter-json.wasm && exit 0 || cd ../../node_modules/tree-sitter-json && tree-sitter generate --abi=13 ./grammar.js && tree-sitter build-wasm && node-gyp rebuild",
+    "build:wasm:copy": "copyfiles -u 4 ../../node_modules/tree-sitter-json/tree-sitter-json.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:lexical-analysis": "cross-env NODE_ENV=test BABEL_ENV=cjs node ./test/perf/lexical-analysis.cjs",
+    "perf:parse-syntactic-analysis-direct": "cross-env NODE_ENV=test  BABEL_ENV=cjs node ./test/perf/parse-syntactic-analysis-direct.cjs",
+    "perf:parse-syntactic-analysis-indirect": "cross-env NODE_ENV=test  BABEL_ENV=cjs node ./test/perf/parse-syntactic-analysis-indirect.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-json": "=0.20.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,53 @@
+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$2: (source: string) => Promise<Tree$1>;
+
+/**
+ * This version of syntactic analysis translates TreeSitter CTS into ApiDOM.
+ * Single traversal pass is needed to get from CST to ApiDOM.
+ */
+declare const analyze$1: (cst: {
+    rootNode: unknown;
+}, { sourceMap }?: {
+    sourceMap?: boolean | undefined;
+}) => ParseResultElement;
+
+type Tree = Tree$1 | Tree$2;
+/**
+ * This version of syntactic analysis does following transformations:
+ *   TreeSitter CST -> JSON AST -> ApiDOM
+ * Two traversals passes are needed to get from CST to ApiDOM.
+ * This analysis is much slower than the direct one, but allows
+ * to do additional analysis magic on JSON AST.
+ */
+declare const analyze: (cst: Tree, { sourceMap }?: {
+    sourceMap?: boolean | undefined;
+}) => ParseResultElement;
+
+declare class JSONMediaTypes extends MediaTypes<string> {
+    latest(): string;
+}
+declare const mediaTypes: JSONMediaTypes;
+
+declare const namespace: _swagger_api_apidom_core.Namespace;
+declare const detectionRegExp: RegExp;
+
+declare const detect: (source: string) => Promise<boolean>;
+interface ParseFunctionOptions {
+    sourceMap?: boolean;
+    syntacticAnalysis?: 'direct' | 'indirect';
+}
+type ParseFunction = (source: string, options?: ParseFunctionOptions) => Promise<ParseResultElement>;
+declare const parse: ParseFunction;
+
+export { detect, detectionRegExp, analyze$2 as lexicalAnalysis, mediaTypes, namespace, parse, analyze$1 as syntacticAnalysis, analyze$1 as syntacticAnalysisDirect, analyze as syntacticAnalysisIndirect };