@speclynx/apidom-parser-adapter-json 1.12.1

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

@@ -0,0 +1,183 @@
+import { JsonArray, JsonDocument, JsonObject, JsonProperty, ParseResult, Error, isNode as isCSTNode, getNodeType as getCSTNodeType } from '@speclynx/apidom-ast';
+import { ParseResultElement, ObjectElement, SourceMapElement, MemberElement, ArrayElement, BooleanElement, NullElement, NumberElement, StringElement, AnnotationElement, isParseResultElement, isPrimitiveElement, isElement, keyMap as keyMapApiDOM, getNodeType as getNodeTypeApiDOM } from '@speclynx/apidom-core';
+export const keyMap = {
+  // @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);
+class JsonAstVisitor {
+  sourceMap = false;
+  annotations;
+  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 = [];
+    }
+  };
+  constructor() {
+    this.annotations = [];
+  }
+  document(node) {
+    const element = new ParseResultElement();
+    // @ts-ignore
+    element._content = node.children;
+    return element;
+  }
+  object(node) {
+    const element = new ObjectElement();
+    // @ts-ignore
+    element._content = node.children;
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  property(node) {
+    const element = new 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 StringElement(value);
+    if (parseError instanceof Error) {
+      element.setMetaProperty('jsonParse', {
+        isError: true,
+        errorType: parseError.name,
+        errorMessage: parseError.message
+      });
+    }
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  array(node) {
+    const element = new ArrayElement();
+    // @ts-ignore
+    element._content = node.children;
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  string(node) {
+    const {
+      value,
+      parseError
+    } = node;
+    const element = new StringElement(value);
+    if (parseError instanceof Error) {
+      element.setMetaProperty('jsonParse', {
+        isError: true,
+        errorType: parseError.name,
+        errorMessage: parseError.message
+      });
+    }
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  number(node) {
+    const element = new NumberElement(Number(node.value));
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  null(node) {
+    const element = new NullElement();
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  true(node) {
+    const element = new BooleanElement(true);
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  false(node) {
+    const element = new BooleanElement(false);
+    this.maybeAddSourceMap(node, element);
+    return element;
+  }
+  literal(node) {
+    if (node.isMissing) {
+      const message = `(Missing ${node.value})`;
+      const element = new 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 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 ParseResultElement();
+      parseResultElement.push(element);
+      return parseResultElement;
+    }
+    this.annotations.push(element);
+    return null;
+  }
+  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);
+  }
+}
+export default JsonAstVisitor;

package/types/apidom-parser-adapter-json.d.ts

@@ -0,0 +1,103 @@
+import { MediaTypes } from '@speclynx/apidom-core';
+import { Namespace } from '@speclynx/apidom-core';
+import { ParseResultElement } from '@speclynx/apidom-core';
+import { Tree } from 'web-tree-sitter';
+
+/**
+ * This version of syntactic analysis translates TreeSitter CTS
+ * directly into 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 ApiDOM.
+ *
+ * Single traversal pass is needed to get from CST to ApiDOM.
+ * @public
+ */
+declare const analyze: (cst: Tree, { sourceMap }?: {
+    sourceMap?: boolean | undefined;
+}) => ParseResultElement;
+export { analyze as syntacticAnalysis }
+export { analyze as syntacticAnalysisDirect }
+
+/**
+ * @public
+ */
+export declare const detect: (source: string) => Promise<boolean>;
+
+/**
+ * @public
+ */
+export declare const detectionRegExp: RegExp;
+
+/**
+ * @public
+ */
+export declare class JSONMediaTypes extends MediaTypes<string> {
+    latest(): string;
+}
+
+/**
+ * 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.
+ * @public
+ */
+export declare const lexicalAnalysis: (source: string) => Promise<Tree>;
+
+/**
+ * @public
+ */
+export declare const mediaTypes: JSONMediaTypes;
+
+/**
+ * @public
+ */
+export declare const namespace: Namespace;
+
+/**
+ * @public
+ */
+export declare const parse: ParseFunction;
+
+/**
+ * @public
+ */
+export declare type ParseFunction = (source: string, options?: ParseFunctionOptions) => Promise<ParseResultElement>;
+
+/**
+ * @public
+ */
+export declare interface ParseFunctionOptions {
+    sourceMap?: boolean;
+    syntacticAnalysis?: 'direct' | 'indirect';
+}
+
+/**
+ * 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
+ */
+export declare const syntacticAnalysisIndirect: (cst: Tree, { sourceMap }?: {
+    sourceMap?: boolean | undefined;
+}) => ParseResultElement;
+
+export { Tree }
+
+export { }