@speclynx/apidom-parser-adapter-json 1.12.1

package/src/syntactic-analysis/indirect/index.cjs

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomAst = require("@speclynx/apidom-ast");
+var _TreeCursorIterator = _interopRequireDefault(require("../TreeCursorIterator.cjs"));
+var _CstVisitor = _interopRequireWildcard(require("./visitors/CstVisitor.cjs"));
+var _JsonAstVisitor = _interopRequireWildcard(require("./visitors/JsonAstVisitor.cjs"));
+/**
+ * @public
+ */
+
+/**
+ * This version of syntactic analysis does following transformations:
+ *   `TreeSitter CST -> JSON AST -> ApiDOM`
+ *
+ * Transient transformation of TreeSitter CST is performed
+ * using TreeSitter cursor. TreeSitter cursor is a stateful object
+ * that allows us to walk syntax tree containing large number of nodes
+ * with maximum efficiency. Using this transient CST transformation
+ * gives us double the performance when syntactically analyzing
+ * CST into JSON AST.
+ *
+ * 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.
+ * @public
+ */
+const analyze = (cst, {
+  sourceMap = false
+} = {}) => {
+  const cursor = cst.walk();
+  const iterator = new _TreeCursorIterator.default(cursor);
+  const [rootNode] = Array.from(iterator);
+  const cstVisitor = new _CstVisitor.default();
+  const astVisitor = new _JsonAstVisitor.default();
+  const jsonAst = (0, _apidomAst.visit)(rootNode, cstVisitor, {
+    // @ts-ignore
+    keyMap: _CstVisitor.keyMap,
+    state: {
+      sourceMap
+    }
+  });
+  return (0, _apidomAst.visit)(jsonAst.rootNode, astVisitor, {
+    // @ts-ignore
+    keyMap: _JsonAstVisitor.keyMap,
+    nodeTypeGetter: _JsonAstVisitor.getNodeType,
+    nodePredicate: _JsonAstVisitor.isNode,
+    state: {
+      sourceMap
+    }
+  });
+};
+var _default = exports.default = analyze;

package/src/syntactic-analysis/indirect/index.mjs

@@ -0,0 +1,49 @@
+import { visit } from '@speclynx/apidom-ast';
+import TreeCursorIterator from "../TreeCursorIterator.mjs";
+import CstVisitor, { keyMap as cstKeyMap } from "./visitors/CstVisitor.mjs";
+import JsonAstVisitor, { keyMap as astKeyMap, isNode, getNodeType } from "./visitors/JsonAstVisitor.mjs";
+/**
+ * @public
+ */
+/**
+ * This version of syntactic analysis does following transformations:
+ *   `TreeSitter CST -> JSON AST -> ApiDOM`
+ *
+ * Transient transformation of TreeSitter CST is performed
+ * using TreeSitter cursor. TreeSitter cursor is a stateful object
+ * that allows us to walk syntax tree containing large number of nodes
+ * with maximum efficiency. Using this transient CST transformation
+ * gives us double the performance when syntactically analyzing
+ * CST into JSON AST.
+ *
+ * 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.
+ * @public
+ */
+const analyze = (cst, {
+  sourceMap = false
+} = {}) => {
+  const cursor = cst.walk();
+  const iterator = new TreeCursorIterator(cursor);
+  const [rootNode] = Array.from(iterator);
+  const cstVisitor = new CstVisitor();
+  const astVisitor = new JsonAstVisitor();
+  const jsonAst = visit(rootNode, cstVisitor, {
+    // @ts-ignore
+    keyMap: cstKeyMap,
+    state: {
+      sourceMap
+    }
+  });
+  return visit(jsonAst.rootNode, astVisitor, {
+    // @ts-ignore
+    keyMap: astKeyMap,
+    nodeTypeGetter: getNodeType,
+    nodePredicate: isNode,
+    state: {
+      sourceMap
+    }
+  });
+};
+export default analyze;

package/src/syntactic-analysis/indirect/visitors/CstVisitor.cjs

@@ -0,0 +1,177 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.keyMap = exports.default = void 0;
+var _apidomAst = require("@speclynx/apidom-ast");
+var _TreeCursorSyntaxNode = _interopRequireDefault(require("../../TreeCursorSyntaxNode.cjs"));
+const keyMap = exports.keyMap = {
+  document: ['children'],
+  object: ['children'],
+  array: ['children'],
+  string: ['children'],
+  property: ['children'],
+  key: ['children'],
+  error: ['children']
+};
+class CstVisitor {
+  static toPosition(node) {
+    const start = new _apidomAst.Point({
+      row: node.startPosition.row,
+      column: node.startPosition.column,
+      char: node.startIndex
+    });
+    const end = new _apidomAst.Point({
+      row: node.endPosition.row,
+      column: node.endPosition.column,
+      char: node.endIndex
+    });
+    return new _apidomAst.Position({
+      start,
+      end
+    });
+  }
+  document = {
+    enter: node => {
+      const position = CstVisitor.toPosition(node);
+      return new _apidomAst.JsonDocument({
+        children: node.children,
+        position,
+        isMissing: node.isMissing
+      });
+    },
+    leave: document => {
+      return new _apidomAst.ParseResult({
+        children: [document]
+      });
+    }
+  };
+  enter(node) {
+    // anonymous literals from CST transformed into AST literal nodes
+    if (node instanceof _TreeCursorSyntaxNode.default && !node.isNamed) {
+      const position = CstVisitor.toPosition(node);
+      const value = node.type || node.text;
+      const {
+        isMissing
+      } = node;
+      return new _apidomAst.Literal({
+        value,
+        position,
+        isMissing
+      });
+    }
+    return undefined;
+  }
+  object(node) {
+    const position = CstVisitor.toPosition(node);
+    return new _apidomAst.JsonObject({
+      children: node.children,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  pair(node) {
+    const position = CstVisitor.toPosition(node);
+    const children = node.children.slice(1);
+    const {
+      keyNode
+    } = node;
+    let jsonKeyValue;
+    let parseError;
+    try {
+      jsonKeyValue = JSON.parse(keyNode?.text ?? '""');
+    } catch (error) {
+      jsonKeyValue = keyNode?.text ?? '';
+      parseError = error instanceof Error ? error : undefined;
+    }
+    const key = new _apidomAst.JsonKey({
+      value: jsonKeyValue,
+      parseError,
+      position: keyNode != null ? CstVisitor.toPosition(keyNode) : undefined,
+      isMissing: keyNode != null ? keyNode.isMissing : false
+    });
+    return new _apidomAst.JsonProperty({
+      children: [key, ...children],
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  array(node) {
+    const position = CstVisitor.toPosition(node);
+    return new _apidomAst.JsonArray({
+      children: node.children,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  string(node) {
+    const position = CstVisitor.toPosition(node);
+    let value;
+    let parseError;
+    try {
+      value = JSON.parse(node.text);
+    } catch (error) {
+      parseError = error instanceof Error ? error : undefined;
+      value = node.text;
+    }
+    return new _apidomAst.JsonString({
+      value,
+      parseError,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  number(node) {
+    const position = CstVisitor.toPosition(node);
+    const value = node.text;
+    return new _apidomAst.JsonNumber({
+      value,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  null(node) {
+    const position = CstVisitor.toPosition(node);
+    const value = node.text;
+    return new _apidomAst.JsonNull({
+      value,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  true(node) {
+    const position = CstVisitor.toPosition(node);
+    const value = node.text;
+    return new _apidomAst.JsonTrue({
+      value,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  false(node) {
+    const position = CstVisitor.toPosition(node);
+    const value = node.text;
+    return new _apidomAst.JsonFalse({
+      value,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  ERROR(node, key, parent, path) {
+    const position = CstVisitor.toPosition(node);
+    const errorNode = new _apidomAst.Error({
+      children: node.children,
+      position,
+      isUnexpected: !node.hasError,
+      isMissing: node.isMissing,
+      value: node.text
+    });
+    if (path.length === 0) {
+      return new _apidomAst.ParseResult({
+        children: [errorNode]
+      });
+    }
+    return errorNode;
+  }
+}
+var _default = exports.default = CstVisitor;

package/src/syntactic-analysis/indirect/visitors/CstVisitor.mjs

@@ -0,0 +1,172 @@
+import { JsonArray, JsonDocument, JsonFalse, JsonNull, JsonNumber, JsonObject, JsonKey, JsonProperty, JsonString, JsonTrue, ParseResult, Position, Point, Literal, Error as ErrorNode } from '@speclynx/apidom-ast';
+import TreeCursorSyntaxNode from "../../TreeCursorSyntaxNode.mjs";
+export const keyMap = {
+  document: ['children'],
+  object: ['children'],
+  array: ['children'],
+  string: ['children'],
+  property: ['children'],
+  key: ['children'],
+  error: ['children']
+};
+class CstVisitor {
+  static toPosition(node) {
+    const start = new Point({
+      row: node.startPosition.row,
+      column: node.startPosition.column,
+      char: node.startIndex
+    });
+    const end = new Point({
+      row: node.endPosition.row,
+      column: node.endPosition.column,
+      char: node.endIndex
+    });
+    return new Position({
+      start,
+      end
+    });
+  }
+  document = {
+    enter: node => {
+      const position = CstVisitor.toPosition(node);
+      return new JsonDocument({
+        children: node.children,
+        position,
+        isMissing: node.isMissing
+      });
+    },
+    leave: document => {
+      return new ParseResult({
+        children: [document]
+      });
+    }
+  };
+  enter(node) {
+    // anonymous literals from CST transformed into AST literal nodes
+    if (node instanceof TreeCursorSyntaxNode && !node.isNamed) {
+      const position = CstVisitor.toPosition(node);
+      const value = node.type || node.text;
+      const {
+        isMissing
+      } = node;
+      return new Literal({
+        value,
+        position,
+        isMissing
+      });
+    }
+    return undefined;
+  }
+  object(node) {
+    const position = CstVisitor.toPosition(node);
+    return new JsonObject({
+      children: node.children,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  pair(node) {
+    const position = CstVisitor.toPosition(node);
+    const children = node.children.slice(1);
+    const {
+      keyNode
+    } = node;
+    let jsonKeyValue;
+    let parseError;
+    try {
+      jsonKeyValue = JSON.parse(keyNode?.text ?? '""');
+    } catch (error) {
+      jsonKeyValue = keyNode?.text ?? '';
+      parseError = error instanceof Error ? error : undefined;
+    }
+    const key = new JsonKey({
+      value: jsonKeyValue,
+      parseError,
+      position: keyNode != null ? CstVisitor.toPosition(keyNode) : undefined,
+      isMissing: keyNode != null ? keyNode.isMissing : false
+    });
+    return new JsonProperty({
+      children: [key, ...children],
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  array(node) {
+    const position = CstVisitor.toPosition(node);
+    return new JsonArray({
+      children: node.children,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  string(node) {
+    const position = CstVisitor.toPosition(node);
+    let value;
+    let parseError;
+    try {
+      value = JSON.parse(node.text);
+    } catch (error) {
+      parseError = error instanceof Error ? error : undefined;
+      value = node.text;
+    }
+    return new JsonString({
+      value,
+      parseError,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  number(node) {
+    const position = CstVisitor.toPosition(node);
+    const value = node.text;
+    return new JsonNumber({
+      value,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  null(node) {
+    const position = CstVisitor.toPosition(node);
+    const value = node.text;
+    return new JsonNull({
+      value,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  true(node) {
+    const position = CstVisitor.toPosition(node);
+    const value = node.text;
+    return new JsonTrue({
+      value,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  false(node) {
+    const position = CstVisitor.toPosition(node);
+    const value = node.text;
+    return new JsonFalse({
+      value,
+      position,
+      isMissing: node.isMissing
+    });
+  }
+  ERROR(node, key, parent, path) {
+    const position = CstVisitor.toPosition(node);
+    const errorNode = new ErrorNode({
+      children: node.children,
+      position,
+      isUnexpected: !node.hasError,
+      isMissing: node.isMissing,
+      value: node.text
+    });
+    if (path.length === 0) {
+      return new ParseResult({
+        children: [errorNode]
+      });
+    }
+    return errorNode;
+  }
+}
+export default CstVisitor;

package/src/syntactic-analysis/indirect/visitors/JsonAstVisitor.cjs

@@ -0,0 +1,189 @@
+"use strict";
+
+exports.__esModule = true;
+exports.keyMap = exports.isNode = exports.getNodeType = exports.default = void 0;
+var _apidomAst = require("@speclynx/apidom-ast");
+var _apidomCore = require("@speclynx/apidom-core");
+const keyMap = exports.keyMap = {
+  // @ts-ignore
+  [_apidomAst.ParseResult.type]: ['children'],
+  // @ts-ignore
+  [_apidomAst.JsonDocument.type]: ['children'],
+  // @ts-ignore
+  [_apidomAst.JsonObject.type]: ['children'],
+  // @ts-ignore
+  [_apidomAst.JsonProperty.type]: ['children'],
+  // @ts-ignore
+  [_apidomAst.JsonArray.type]: ['children'],
+  // @ts-ignore
+  [_apidomAst.Error.type]: ['children'],
+  ..._apidomCore.keyMap
+};
+const getNodeType = node => {
+  if ((0, _apidomCore.isParseResultElement)(node)) {
+    return 'ParseResultElement';
+  }
+  if ((0, _apidomCore.isElement)(node)) {
+    return (0, _apidomCore.getNodeType)(node);
+  }
+  return (0, _apidomAst.getNodeType)(node);
+};
+exports.getNodeType = getNodeType;
+const isNode = element => (0, _apidomCore.isElement)(element) || (0, _apidomAst.isNode)(element);
+exports.isNode = isNode;
+class JsonAstVisitor {
+  sourceMap = false;
+  annotations;
+  ParseResultElement = {
+    leave: element => {
+      // mark first-non Annotation element as result
+      // @ts-ignore
+      const elements = element.findElements(_apidomCore.isPrimitiveElement);
+      if (elements.length > 0) {
+        const resultElement = elements[0];
+        resultElement.classes.push('result');
+      }
+
+      // provide annotations
+      this.annotations.forEach(annotationElement => {
+        element.push(annotationElement);
+      });
+      this.annotations = [];
+    }
+  };
+  constructor() {
+    this.annotations = [];
+  }
+  document(node) {
+    const element = new _apidomCore.ParseResultElement();
+    // @ts-ignore
+    element._content = node.children;
+    return element;
+  }
+  object(node) {
+    const element = new _apidomCore.ObjectElement();
+    // @ts-ignore
+    element._content = node.children;
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  property(node) {
+    const element = new _apidomCore.MemberElement();
+
+    // @ts-ignore
+    element.content.key = node.key;
+    // @ts-ignore
+    element.content.value = node.value;
+    this.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
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .filter(child => child.type === 'error')
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .forEach(errorNode => {
+        this.error(errorNode, node, [], [node]);
+      });
+    }
+    return element;
+  }
+  key(node) {
+    const {
+      value,
+      parseError
+    } = node;
+    const element = new _apidomCore.StringElement(value);
+    if (parseError instanceof _apidomAst.Error) {
+      element.setMetaProperty('jsonParse', {
+        isError: true,
+        errorType: parseError.name,
+        errorMessage: parseError.message
+      });
+    }
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  array(node) {
+    const element = new _apidomCore.ArrayElement();
+    // @ts-ignore
+    element._content = node.children;
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  string(node) {
+    const {
+      value,
+      parseError
+    } = node;
+    const element = new _apidomCore.StringElement(value);
+    if (parseError instanceof _apidomAst.Error) {
+      element.setMetaProperty('jsonParse', {
+        isError: true,
+        errorType: parseError.name,
+        errorMessage: parseError.message
+      });
+    }
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  number(node) {
+    const element = new _apidomCore.NumberElement(Number(node.value));
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  null(node) {
+    const element = new _apidomCore.NullElement();
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  true(node) {
+    const element = new _apidomCore.BooleanElement(true);
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  false(node) {
+    const element = new _apidomCore.BooleanElement(false);
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  literal(node) {
+    if (node.isMissing) {
+      const message = `(Missing ${node.value})`;
+      const element = new _apidomCore.AnnotationElement(message);
+      element.classes.push('warning');
+      this.maybeAddSourceMap(node, element);
+      this.annotations.push(element);
+    }
+    return null;
+  }
+  error(node, key, parent, path) {
+    const message = node.isUnexpected ? `(Unexpected ${node.value})` : `(Error ${node.value})`;
+    const element = new _apidomCore.AnnotationElement(message);
+    element.classes.push('error');
+    this.maybeAddSourceMap(node, element);
+    if (path.length === 0) {
+      // no document to visit, only error is present in CST
+      const parseResultElement = new _apidomCore.ParseResultElement();
+      parseResultElement.push(element);
+      return parseResultElement;
+    }
+    this.annotations.push(element);
+    return null;
+  }
+  maybeAddSourceMap(node, element) {
+    if (!this.sourceMap) {
+      return;
+    }
+    const sourceMap = new _apidomCore.SourceMapElement();
+    // @ts-ignore
+    sourceMap.position = node.position;
+    // @ts-ignore
+    sourceMap.astNode = node;
+    element.meta.set('sourceMap', sourceMap);
+  }
+}
+var _default = exports.default = JsonAstVisitor;