@speclynx/apidom-parser-adapter-json 1.12.2 → 2.0.1

package/src/tree-sitter/syntactic-analysis/index.cjs

@@ -0,0 +1,223 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+const getCursorInfo = cursor => ({
+  type: cursor.nodeType,
+  startPosition: cursor.startPosition,
+  endPosition: cursor.endPosition,
+  startIndex: cursor.startIndex,
+  endIndex: cursor.endIndex,
+  text: cursor.nodeText,
+  isNamed: cursor.nodeIsNamed,
+  isMissing: cursor.nodeIsMissing,
+  hasError: cursor.currentNode.hasError,
+  fieldName: cursor.currentFieldName
+});
+const maybeAddSourceMap = (info, element, ctx) => {
+  if (!ctx.sourceMap) {
+    return;
+  }
+  element.startLine = info.startPosition.row;
+  element.startCharacter = info.startPosition.column;
+  element.startOffset = info.startIndex;
+  element.endLine = info.endPosition.row;
+  element.endCharacter = info.endPosition.column;
+  element.endOffset = info.endIndex;
+};
+const transform = (cursor, transformerMap, ctx) => {
+  const info = getCursorInfo(cursor);
+
+  // Handle missing anonymous literals
+  if (!info.isNamed && info.isMissing) {
+    const value = info.type || info.text;
+    const message = `(Missing ${value})`;
+    const element = new _apidomDatamodel.AnnotationElement(message);
+    element.classes.push('warning');
+    maybeAddSourceMap(info, element, ctx);
+    ctx.annotations.push(element);
+    return null;
+  }
+  const transformer = transformerMap[info.type];
+  if (!transformer) {
+    return null; // remove unrecognized nodes
+  }
+  return transformer(cursor, ctx);
+};
+const transformChildren = (cursor, transformerMap, ctx) => {
+  const results = [];
+  if (cursor.gotoFirstChild()) {
+    do {
+      const transformed = transform(cursor, transformerMap, ctx);
+      if (transformed !== null) {
+        results.push(transformed);
+      }
+    } while (cursor.gotoNextSibling());
+    cursor.gotoParent();
+  }
+  return results;
+};
+const createTransformers = transformerMap => ({
+  document(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new _apidomDatamodel.ParseResultElement();
+    maybeAddSourceMap(info, element, ctx);
+
+    // Transform children
+    const children = transformChildren(cursor, transformerMap, ctx);
+    for (const child of children) {
+      element.push(child);
+    }
+
+    // Mark first non-Annotation element as result
+    // @ts-ignore
+    const elements = element.findElements(_apidomDatamodel.isPrimitiveElement);
+    if (elements.length > 0) {
+      elements[0].classes.push('result');
+    }
+
+    // Add collected annotations
+    for (const annotation of ctx.annotations) {
+      element.push(annotation);
+    }
+    ctx.annotations = [];
+    return element;
+  },
+  object(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new _apidomDatamodel.ObjectElement();
+    maybeAddSourceMap(info, element, ctx);
+
+    // Transform children (pairs)
+    const children = transformChildren(cursor, transformerMap, ctx);
+    for (const child of children) {
+      element.push(child);
+    }
+    return element;
+  },
+  array(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new _apidomDatamodel.ArrayElement();
+    maybeAddSourceMap(info, element, ctx);
+
+    // Transform children
+    const children = transformChildren(cursor, transformerMap, ctx);
+    for (const child of children) {
+      element.push(child);
+    }
+    return element;
+  },
+  pair(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    let key = null;
+    let value = null;
+
+    // Find key and value by field name
+    if (cursor.gotoFirstChild()) {
+      do {
+        const fieldName = cursor.currentFieldName;
+        if (fieldName === 'key') {
+          key = transform(cursor, transformerMap, ctx);
+        } else if (fieldName === 'value') {
+          value = transform(cursor, transformerMap, ctx);
+        } else if (cursor.nodeType === 'ERROR') {
+          // Process error nodes
+          transform(cursor, transformerMap, ctx);
+        }
+      } while (cursor.gotoNextSibling());
+      cursor.gotoParent();
+    }
+    const element = new _apidomDatamodel.MemberElement(key ?? new _apidomDatamodel.StringElement(''), value ?? new _apidomDatamodel.StringElement(''));
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  string(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    let element;
+    try {
+      element = new _apidomDatamodel.StringElement(JSON.parse(info.text));
+    } catch (error) {
+      element = new _apidomDatamodel.StringElement(info.text);
+      if (error instanceof Error) {
+        element.meta.set('jsonParse', {
+          isError: true,
+          errorType: error.name,
+          errorMessage: error.message
+        });
+      }
+    }
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  number(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new _apidomDatamodel.NumberElement(Number(info.text));
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  null(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new _apidomDatamodel.NullElement();
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  true(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new _apidomDatamodel.BooleanElement(true);
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  false(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new _apidomDatamodel.BooleanElement(false);
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  ERROR(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const isUnexpected = !info.hasError;
+    const message = isUnexpected ? `(Unexpected ${info.text})` : `(Error ${info.text})`;
+    const element = new _apidomDatamodel.AnnotationElement(message);
+    element.classes.push('error');
+    maybeAddSourceMap(info, element, ctx);
+    ctx.annotations.push(element);
+    return null;
+  }
+});
+
+// Create the transformers map with self-reference for recursion
+const transformers = {};
+Object.assign(transformers, createTransformers(transformers));
+
+/**
+ * Syntactic analysis translates TreeSitter CST directly into ApiDOM.
+ *
+ * Direct transformation from TreeSitter CST using TreeSitter cursor.
+ * TreeSitter cursor is a stateful object that allows us to walk syntax tree
+ * containing large number of nodes with maximum efficiency.
+ *
+ * Single pass transformation from CST to ApiDOM.
+ * @public
+ */
+const analyze = (cst, {
+  sourceMap = false
+} = {}) => {
+  const cursor = cst.walk();
+  const ctx = {
+    sourceMap,
+    annotations: []
+  };
+  const result = transform(cursor, transformers, ctx);
+
+  // Handle case where there's no document, only errors
+  if (result === null) {
+    const parseResult = new _apidomDatamodel.ParseResultElement();
+    for (const annotation of ctx.annotations) {
+      parseResult.push(annotation);
+    }
+    return parseResult;
+  }
+  return result;
+};
+var _default = exports.default = analyze;

package/src/tree-sitter/syntactic-analysis/index.mjs

@@ -0,0 +1,219 @@
+import { BooleanElement, NullElement, NumberElement, ParseResultElement, MemberElement, ObjectElement, ArrayElement, StringElement, AnnotationElement, isPrimitiveElement } from '@speclynx/apidom-datamodel';
+const getCursorInfo = cursor => ({
+  type: cursor.nodeType,
+  startPosition: cursor.startPosition,
+  endPosition: cursor.endPosition,
+  startIndex: cursor.startIndex,
+  endIndex: cursor.endIndex,
+  text: cursor.nodeText,
+  isNamed: cursor.nodeIsNamed,
+  isMissing: cursor.nodeIsMissing,
+  hasError: cursor.currentNode.hasError,
+  fieldName: cursor.currentFieldName
+});
+const maybeAddSourceMap = (info, element, ctx) => {
+  if (!ctx.sourceMap) {
+    return;
+  }
+  element.startLine = info.startPosition.row;
+  element.startCharacter = info.startPosition.column;
+  element.startOffset = info.startIndex;
+  element.endLine = info.endPosition.row;
+  element.endCharacter = info.endPosition.column;
+  element.endOffset = info.endIndex;
+};
+const transform = (cursor, transformerMap, ctx) => {
+  const info = getCursorInfo(cursor);
+
+  // Handle missing anonymous literals
+  if (!info.isNamed && info.isMissing) {
+    const value = info.type || info.text;
+    const message = `(Missing ${value})`;
+    const element = new AnnotationElement(message);
+    element.classes.push('warning');
+    maybeAddSourceMap(info, element, ctx);
+    ctx.annotations.push(element);
+    return null;
+  }
+  const transformer = transformerMap[info.type];
+  if (!transformer) {
+    return null; // remove unrecognized nodes
+  }
+  return transformer(cursor, ctx);
+};
+const transformChildren = (cursor, transformerMap, ctx) => {
+  const results = [];
+  if (cursor.gotoFirstChild()) {
+    do {
+      const transformed = transform(cursor, transformerMap, ctx);
+      if (transformed !== null) {
+        results.push(transformed);
+      }
+    } while (cursor.gotoNextSibling());
+    cursor.gotoParent();
+  }
+  return results;
+};
+const createTransformers = transformerMap => ({
+  document(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new ParseResultElement();
+    maybeAddSourceMap(info, element, ctx);
+
+    // Transform children
+    const children = transformChildren(cursor, transformerMap, ctx);
+    for (const child of children) {
+      element.push(child);
+    }
+
+    // Mark first non-Annotation element as result
+    // @ts-ignore
+    const elements = element.findElements(isPrimitiveElement);
+    if (elements.length > 0) {
+      elements[0].classes.push('result');
+    }
+
+    // Add collected annotations
+    for (const annotation of ctx.annotations) {
+      element.push(annotation);
+    }
+    ctx.annotations = [];
+    return element;
+  },
+  object(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new ObjectElement();
+    maybeAddSourceMap(info, element, ctx);
+
+    // Transform children (pairs)
+    const children = transformChildren(cursor, transformerMap, ctx);
+    for (const child of children) {
+      element.push(child);
+    }
+    return element;
+  },
+  array(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new ArrayElement();
+    maybeAddSourceMap(info, element, ctx);
+
+    // Transform children
+    const children = transformChildren(cursor, transformerMap, ctx);
+    for (const child of children) {
+      element.push(child);
+    }
+    return element;
+  },
+  pair(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    let key = null;
+    let value = null;
+
+    // Find key and value by field name
+    if (cursor.gotoFirstChild()) {
+      do {
+        const fieldName = cursor.currentFieldName;
+        if (fieldName === 'key') {
+          key = transform(cursor, transformerMap, ctx);
+        } else if (fieldName === 'value') {
+          value = transform(cursor, transformerMap, ctx);
+        } else if (cursor.nodeType === 'ERROR') {
+          // Process error nodes
+          transform(cursor, transformerMap, ctx);
+        }
+      } while (cursor.gotoNextSibling());
+      cursor.gotoParent();
+    }
+    const element = new MemberElement(key ?? new StringElement(''), value ?? new StringElement(''));
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  string(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    let element;
+    try {
+      element = new StringElement(JSON.parse(info.text));
+    } catch (error) {
+      element = new StringElement(info.text);
+      if (error instanceof Error) {
+        element.meta.set('jsonParse', {
+          isError: true,
+          errorType: error.name,
+          errorMessage: error.message
+        });
+      }
+    }
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  number(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new NumberElement(Number(info.text));
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  null(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new NullElement();
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  true(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new BooleanElement(true);
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  false(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const element = new BooleanElement(false);
+    maybeAddSourceMap(info, element, ctx);
+    return element;
+  },
+  ERROR(cursor, ctx) {
+    const info = getCursorInfo(cursor);
+    const isUnexpected = !info.hasError;
+    const message = isUnexpected ? `(Unexpected ${info.text})` : `(Error ${info.text})`;
+    const element = new AnnotationElement(message);
+    element.classes.push('error');
+    maybeAddSourceMap(info, element, ctx);
+    ctx.annotations.push(element);
+    return null;
+  }
+});
+
+// Create the transformers map with self-reference for recursion
+const transformers = {};
+Object.assign(transformers, createTransformers(transformers));
+
+/**
+ * Syntactic analysis translates TreeSitter CST directly into ApiDOM.
+ *
+ * Direct transformation from TreeSitter CST using TreeSitter cursor.
+ * TreeSitter cursor is a stateful object that allows us to walk syntax tree
+ * containing large number of nodes with maximum efficiency.
+ *
+ * Single pass transformation from CST to ApiDOM.
+ * @public
+ */
+const analyze = (cst, {
+  sourceMap = false
+} = {}) => {
+  const cursor = cst.walk();
+  const ctx = {
+    sourceMap,
+    annotations: []
+  };
+  const result = transform(cursor, transformers, ctx);
+
+  // Handle case where there's no document, only errors
+  if (result === null) {
+    const parseResult = new ParseResultElement();
+    for (const annotation of ctx.annotations) {
+      parseResult.push(annotation);
+    }
+    return parseResult;
+  }
+  return result;
+};
+export default analyze;

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

@@ -1,37 +1,24 @@
 import { MediaTypes } from '@speclynx/apidom-core';
-import { Namespace } from '@speclynx/apidom-core';
-import { ParseResultElement } from '@speclynx/apidom-core';
+import { Namespace } from '@speclynx/apidom-datamodel';
+import { ParseResultElement } from '@speclynx/apidom-datamodel';
 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 }
+export declare const detect: (source: string, { strict }?: DetectOptions) => Promise<boolean>;
 
 /**
  * @public
  */
-export declare const detect: (source: string) => Promise<boolean>;
+export declare const detectionRegExp: RegExp;
 
 /**
  * @public
  */
-export declare const detectionRegExp: RegExp;
+export declare interface DetectOptions {
+    strict?: boolean;
+}
 
 /**
  * @public
@@ -75,26 +62,20 @@ export declare type ParseFunction = (source: string, options?: ParseFunctionOpti
  */
 export declare interface ParseFunctionOptions {
     sourceMap?: boolean;
-    syntacticAnalysis?: 'direct' | 'indirect';
+    strict?: boolean;
 }
 
 /**
- * This version of syntactic analysis does following transformations:
- *   `TreeSitter CST -> JSON AST -> ApiDOM`
+ * Syntactic analysis translates TreeSitter CST 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 JSON AST.
+ * Direct transformation from TreeSitter CST using TreeSitter cursor.
+ * TreeSitter cursor is a stateful object that allows us to walk syntax tree
+ * containing large number of nodes with maximum efficiency.
  *
- * 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.
+ * Single pass transformation from CST to ApiDOM.
  * @public
  */
-export declare const syntacticAnalysisIndirect: (cst: Tree, { sourceMap }?: {
+export declare const syntacticAnalysis: (cst: Tree, { sourceMap }?: {
     sourceMap?: boolean | undefined;
 }) => ParseResultElement;
 

package/src/syntactic-analysis/TreeCursorIterator.cjs

@@ -1,62 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
-exports.__esModule = true;
-exports.default = void 0;
-var _TreeCursorSyntaxNode = _interopRequireDefault(require("./TreeCursorSyntaxNode.cjs"));
-class TreeCursorIterator {
-  cursor;
-  constructor(cursor) {
-    this.cursor = cursor;
-  }
-  document() {
-    return new _TreeCursorSyntaxNode.default(this.cursor);
-  }
-  object() {
-    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
-  }
-  array() {
-    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
-  }
-  pair() {
-    return new _TreeCursorSyntaxNode.default(this.cursor);
-  }
-  string() {
-    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
-  }
-  number() {
-    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
-  }
-  null() {
-    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
-  }
-  true() {
-    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
-  }
-  false() {
-    return new _TreeCursorSyntaxNode.default(this.cursor).setFieldName(this.cursor);
-  }
-  ERROR() {
-    return new _TreeCursorSyntaxNode.default(this.cursor).setHasError(this.cursor);
-  }
-  *[Symbol.iterator]() {
-    let node;
-    if (this.cursor.nodeType in this) {
-      // @ts-ignore
-      node = this[this.cursor.nodeType]();
-    } else {
-      node = new _TreeCursorSyntaxNode.default(this.cursor);
-    }
-    if (this.cursor.gotoFirstChild()) {
-      const [firstChild] = new TreeCursorIterator(this.cursor);
-      node.pushChildren(firstChild);
-      while (this.cursor.gotoNextSibling()) {
-        const firstChildSiblings = new TreeCursorIterator(this.cursor);
-        node.pushChildren(...firstChildSiblings);
-      }
-      this.cursor.gotoParent();
-    }
-    yield node;
-  }
-}
-var _default = exports.default = TreeCursorIterator;

package/src/syntactic-analysis/TreeCursorIterator.mjs

@@ -1,57 +0,0 @@
-import TreeCursorSyntaxNode from "./TreeCursorSyntaxNode.mjs";
-class TreeCursorIterator {
-  cursor;
-  constructor(cursor) {
-    this.cursor = cursor;
-  }
-  document() {
-    return new TreeCursorSyntaxNode(this.cursor);
-  }
-  object() {
-    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
-  }
-  array() {
-    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
-  }
-  pair() {
-    return new TreeCursorSyntaxNode(this.cursor);
-  }
-  string() {
-    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
-  }
-  number() {
-    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
-  }
-  null() {
-    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
-  }
-  true() {
-    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
-  }
-  false() {
-    return new TreeCursorSyntaxNode(this.cursor).setFieldName(this.cursor);
-  }
-  ERROR() {
-    return new TreeCursorSyntaxNode(this.cursor).setHasError(this.cursor);
-  }
-  *[Symbol.iterator]() {
-    let node;
-    if (this.cursor.nodeType in this) {
-      // @ts-ignore
-      node = this[this.cursor.nodeType]();
-    } else {
-      node = new TreeCursorSyntaxNode(this.cursor);
-    }
-    if (this.cursor.gotoFirstChild()) {
-      const [firstChild] = new TreeCursorIterator(this.cursor);
-      node.pushChildren(firstChild);
-      while (this.cursor.gotoNextSibling()) {
-        const firstChildSiblings = new TreeCursorIterator(this.cursor);
-        node.pushChildren(...firstChildSiblings);
-      }
-      this.cursor.gotoParent();
-    }
-    yield node;
-  }
-}
-export default TreeCursorIterator;

package/src/syntactic-analysis/TreeCursorSyntaxNode.cjs

@@ -1,51 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.default = void 0;
-class TreeCursorSyntaxNode {
-  type;
-  startPosition;
-  endPosition;
-  startIndex;
-  endIndex;
-  text;
-  isNamed;
-  isMissing;
-  fieldName = null;
-  hasError = false;
-  children = [];
-  constructor(cursor) {
-    this.type = cursor.nodeType;
-    this.startPosition = cursor.startPosition;
-    this.endPosition = cursor.endPosition;
-    this.startIndex = cursor.startIndex;
-    this.endIndex = cursor.endIndex;
-    this.text = cursor.nodeText;
-    this.isNamed = cursor.nodeIsNamed;
-    this.isMissing = cursor.nodeIsMissing;
-  }
-  get keyNode() {
-    if (this.type === 'pair') {
-      return this.children.find(node => node.fieldName === 'key');
-    }
-    return undefined;
-  }
-  get valueNode() {
-    if (this.type === 'pair') {
-      return this.children.find(node => node.fieldName === 'value');
-    }
-    return undefined;
-  }
-  setFieldName(cursor) {
-    this.fieldName = cursor.currentFieldName;
-    return this;
-  }
-  setHasError(cursor) {
-    this.hasError = cursor.currentNode.hasError;
-    return this;
-  }
-  pushChildren(...children) {
-    this.children.push(...children);
-  }
-}
-var _default = exports.default = TreeCursorSyntaxNode;