@swagger-api/apidom-json-pointer-relative 0.75.0 → 0.76.0

package/es/compile.js

@@ -1,22 +1,29 @@
 import { compile as compileJsonPointer } from '@swagger-api/apidom-json-pointer';
-// compile :: RelativeJSONPointer -> String
+import CompilationRelativeJsonPointerError from "./errors/CompilationRelativeJsonPointerError.js"; // compile :: RelativeJSONPointer -> String
 const compile = relativeJsonPointer => {
-  let relativePointer = '';
+  try {
+    let relativePointer = '';
 
-  // non-negative-integer
-  relativePointer += String(relativeJsonPointer.nonNegativeIntegerPrefix);
+    // non-negative-integer
+    relativePointer += String(relativeJsonPointer.nonNegativeIntegerPrefix);
 
-  // index-manipulation
-  if (typeof relativeJsonPointer.indexManipulation === 'number') {
-    relativePointer += String(relativeJsonPointer.indexManipulation);
+    // index-manipulation
+    if (typeof relativeJsonPointer.indexManipulation === 'number') {
+      relativePointer += String(relativeJsonPointer.indexManipulation);
+    }
+    if (Array.isArray(relativeJsonPointer.jsonPointerTokens)) {
+      // <json-pointer>
+      relativePointer += compileJsonPointer(relativeJsonPointer.jsonPointerTokens);
+    } else if (relativeJsonPointer.hashCharacter) {
+      // "#"
+      relativePointer += '#';
+    }
+    return relativePointer;
+  } catch (error) {
+    throw new CompilationRelativeJsonPointerError('Relative JSON Pointer compilation encountered an error.', {
+      relativePointer: relativeJsonPointer,
+      cause: error
+    });
   }
-  if (Array.isArray(relativeJsonPointer.jsonPointerTokens)) {
-    // <json-pointer>
-    relativePointer += compileJsonPointer(relativeJsonPointer.jsonPointerTokens);
-  } else if (relativeJsonPointer.hashCharacter) {
-    // "#"
-    relativePointer += '#';
-  }
-  return relativePointer;
 };
 export default compile;

package/es/errors/CompilationRelativeJsonPointerError.js

@@ -0,0 +1,20 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+import RelativeJsonPointerError from "./RelativeJsonPointerError.js";
+class CompilationRelativeJsonPointerError extends RelativeJsonPointerError {
+  constructor(message, structuredOptions) {
+    super(message, structuredOptions);
+    _defineProperty(this, "nonNegativeIntegerPrefix", void 0);
+    _defineProperty(this, "indexManipulation", void 0);
+    _defineProperty(this, "jsonPointerTokens", void 0);
+    _defineProperty(this, "hashCharacter", void 0);
+    if (typeof structuredOptions !== 'undefined') {
+      this.nonNegativeIntegerPrefix = structuredOptions.relativePointer.nonNegativeIntegerPrefix;
+      this.indexManipulation = structuredOptions.relativePointer.indexManipulation;
+      this.hashCharacter = structuredOptions.relativePointer.hashCharacter;
+      if (Array.isArray(structuredOptions.relativePointer.jsonPointerTokens)) {
+        this.jsonPointerTokens = [...structuredOptions.relativePointer.jsonPointerTokens];
+      }
+    }
+  }
+}
+export default CompilationRelativeJsonPointerError;

package/es/errors/EvaluationRelativeJsonPointerError.js

@@ -1,12 +1,33 @@
-export default class EvaluationRelativeJsonPointerError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = this.constructor.name;
-    this.message = message;
-    if (typeof Error.captureStackTrace === 'function') {
-      Error.captureStackTrace(this, this.constructor);
-    } else {
-      this.stack = new Error(message).stack;
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+import { hasElementSourceMap, toValue } from '@swagger-api/apidom-core';
+import RelativeJsonPointerError from "./RelativeJsonPointerError.js";
+class EvaluationRelativeJsonPointerError extends RelativeJsonPointerError {
+  constructor(message, structuredOptions) {
+    super(message, structuredOptions);
+    _defineProperty(this, "relativePointer", void 0);
+    _defineProperty(this, "currentElement", void 0);
+    _defineProperty(this, "currentElementSourceMap", void 0);
+    _defineProperty(this, "rootElement", void 0);
+    _defineProperty(this, "rootElementSourceMap", void 0);
+    _defineProperty(this, "cursorElement", void 0);
+    _defineProperty(this, "cursorElementSourceMap", void 0);
+    if (typeof structuredOptions !== 'undefined') {
+      this.relativePointer = structuredOptions.relativePointer;
+      this.currentElement = structuredOptions.currentElement.element;
+      if (hasElementSourceMap(structuredOptions.currentElement)) {
+        this.currentElementSourceMap = toValue(structuredOptions.currentElement.getMetaProperty('sourceMap'));
+      }
+      this.rootElement = structuredOptions.rootElement.element;
+      if (hasElementSourceMap(structuredOptions.rootElement)) {
+        this.rootElementSourceMap = toValue(structuredOptions.rootElement.getMetaProperty('sourceMap'));
+      }
+      if (typeof structuredOptions.cursorElement !== 'undefined') {
+        this.cursorElement = structuredOptions.cursorElement.element;
+        if (hasElementSourceMap(structuredOptions.cursorElement)) {
+          this.cursorElementSourceMap = toValue(structuredOptions.cursorElement.getMetaProperty('sourceMap'));
+        }
+      }
     }
   }
-}
+}
+export default EvaluationRelativeJsonPointerError;

package/es/errors/InvalidRelativeJsonPointerError.js

@@ -1,12 +1,11 @@
-export default class InvalidRelativeJsonPointerError extends Error {
-  constructor(relativePointer) {
-    super(`Invalid Relative JSON Pointer "${relativePointer}".`);
-    this.name = this.constructor.name;
-    this.message = `Invalid Relative JSON Pointer "${relativePointer}".`;
-    if (typeof Error.captureStackTrace === 'function') {
-      Error.captureStackTrace(this, this.constructor);
-    } else {
-      this.stack = new Error(`Invalid Relative JSON Pointer "${relativePointer}".`).stack;
+import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
+import RelativeJsonPointerError from "./RelativeJsonPointerError.js";
+export default class InvalidRelativeJsonPointerError extends RelativeJsonPointerError {
+  constructor(message, structuredOptions) {
+    super(message, structuredOptions);
+    _defineProperty(this, "relativePointer", void 0);
+    if (typeof structuredOptions !== 'undefined') {
+      this.relativePointer = structuredOptions.relativePointer;
     }
   }
 }

package/es/errors/RelativeJsonPointerError.js

@@ -0,0 +1,3 @@
+import { ApiDOMStructuredError } from '@swagger-api/apidom-error';
+class RelativeJsonPointerError extends ApiDOMStructuredError {}
+export default RelativeJsonPointerError;

package/es/evaluate.js

@@ -1,8 +1,9 @@
 import { visit, BREAK, isElement, isMemberElement, isArrayElement, NumberElement } from '@swagger-api/apidom-core';
 import { compile as compileJsonPointer, evaluate as evaluateJsonPointer } from '@swagger-api/apidom-json-pointer';
 import { last } from 'ramda';
-import { EvaluationRelativeJsonPointerError } from "./errors/index.js";
-import parse from "./parse.js"; // evaluates Relative JSON Pointer against ApiDOM fragment
+import EvaluationRelativeJsonPointerError from "./errors/EvaluationRelativeJsonPointerError.js";
+import parse from "./parse.js";
+// evaluates Relative JSON Pointer against ApiDOM fragment
 const evaluate = (relativePointer, currentElement, rootElement) => {
   let ancestorLineage = [];
   let cursor = currentElement;
@@ -16,12 +17,33 @@ const evaluate = (relativePointer, currentElement, rootElement) => {
     }
   });
   if (ancestorLineage.length === 0) {
-    throw new EvaluationRelativeJsonPointerError('Current element not found inside the root element');
+    throw new EvaluationRelativeJsonPointerError('Relative JSON Pointer evaluation failed. Current element not found inside the root element', {
+      relativePointer,
+      currentElement,
+      rootElement,
+      cursorElement: cursor
+    });
   }
   if (last(ancestorLineage) === rootElement) {
-    throw new EvaluationRelativeJsonPointerError('Current element cannot be the root element');
+    throw new EvaluationRelativeJsonPointerError('Relative JSON Pointer evaluation failed. Current element cannot be the root element', {
+      relativePointer,
+      currentElement,
+      rootElement,
+      cursorElement: cursor
+    });
+  }
+  let relativeJsonPointer;
+  try {
+    relativeJsonPointer = parse(relativePointer);
+  } catch (error) {
+    throw new EvaluationRelativeJsonPointerError('Relative JSON Pointer evaluation failed while parsing the pointer.', {
+      relativePointer,
+      currentElement,
+      rootElement,
+      cursorElement: cursor,
+      cause: error
+    });
   }
-  const relativeJsonPointer = parse(relativePointer);
 
   // non-negative-integer
   if (relativeJsonPointer.nonNegativeIntegerPrefix > 0) {
@@ -35,7 +57,12 @@ const evaluate = (relativePointer, currentElement, rootElement) => {
       }
     }
     if (typeof cursor === 'undefined') {
-      throw new EvaluationRelativeJsonPointerError(`Evaluation failed on non-negative-integer prefix of "${relativeJsonPointer.nonNegativeIntegerPrefix}"`);
+      throw new EvaluationRelativeJsonPointerError(`Relative JSON Pointer evaluation failed on non-negative-integer prefix of "${relativeJsonPointer.nonNegativeIntegerPrefix}"`, {
+        relativePointer,
+        currentElement,
+        rootElement,
+        cursorElement: cursor
+      });
     }
     ancestorLineage = ancestorLineageCopy;
   }
@@ -44,13 +71,23 @@ const evaluate = (relativePointer, currentElement, rootElement) => {
   if (typeof relativeJsonPointer.indexManipulation === 'number') {
     const containedArray = last(ancestorLineage);
     if (typeof containedArray === 'undefined' || !isArrayElement(containedArray)) {
-      throw new EvaluationRelativeJsonPointerError(`Evaluation failed on index-manipulation "${relativeJsonPointer.indexManipulation}"`);
+      throw new EvaluationRelativeJsonPointerError(`Relative JSON Pointer evaluation failed failed on index-manipulation "${relativeJsonPointer.indexManipulation}"`, {
+        relativePointer,
+        currentElement,
+        rootElement,
+        cursorElement: cursor
+      });
     }
     const currentCursorIndex = containedArray.content.indexOf(cursor);
     const newCursorIndex = currentCursorIndex + relativeJsonPointer.indexManipulation;
     cursor = containedArray.content[newCursorIndex];
     if (typeof cursor === 'undefined') {
-      throw new EvaluationRelativeJsonPointerError(`Evaluation failed on index-manipulation "${relativeJsonPointer.indexManipulation}"`);
+      throw new EvaluationRelativeJsonPointerError(`Relative JSON Pointer evaluation failed on index-manipulation "${relativeJsonPointer.indexManipulation}"`, {
+        relativePointer,
+        currentElement,
+        rootElement,
+        cursorElement: cursor
+      });
     }
   }
   if (Array.isArray(relativeJsonPointer.jsonPointerTokens)) {
@@ -60,7 +97,12 @@ const evaluate = (relativePointer, currentElement, rootElement) => {
   } else if (relativeJsonPointer.hashCharacter) {
     // "#"
     if (cursor === rootElement) {
-      throw new EvaluationRelativeJsonPointerError('Current element cannot be the root element to apply "#"');
+      throw new EvaluationRelativeJsonPointerError('Relative JSON Pointer evaluation failed. Current element cannot be the root element to apply "#"', {
+        relativePointer,
+        currentElement,
+        rootElement,
+        cursorElement: cursor
+      });
     }
     const parentElement = last(ancestorLineage);
     if (typeof parentElement !== 'undefined') {

package/es/index.js

@@ -1,4 +1,7 @@
+export { default as RelativeJsonPointerError } from "./errors/RelativeJsonPointerError.js";
+export { default as InvalidRelativeJsonPointerError } from "./errors/InvalidRelativeJsonPointerError.js";
+export { default as EvaluationRelativeJsonPointerError } from "./errors/EvaluationRelativeJsonPointerError.js";
+export { default as CompilationRelativeJsonPointerError } from "./errors/CompilationRelativeJsonPointerError.js";
 export { default as parse, isRelativeJsonPointer } from "./parse.js";
 export { default as compile } from "./compile.js";
-export { default as evaluate } from "./evaluate.js";
-export { InvalidRelativeJsonPointerError, EvaluationRelativeJsonPointerError } from "./errors/index.js";
+export { default as evaluate } from "./evaluate.js";

package/es/parse.js

@@ -1,5 +1,5 @@
 import { parse as parseJsonPointer } from '@swagger-api/apidom-json-pointer';
-import { InvalidRelativeJsonPointerError } from "./errors/index.js";
+import InvalidRelativeJsonPointerError from "./errors/InvalidRelativeJsonPointerError.js";
 const nonNegativeIntegerPrefixRegExp = '(?<nonNegativeIntegerPrefix>[1-9]\\d*|0)';
 const indexManipulationRegExp = '(?<indexManipulation>[+-][1-9]\\d*|0)';
 const hashCharacterRegExp = '(?<hashCharacter>#)';
@@ -13,22 +13,30 @@ export const isRelativeJsonPointer = value => {
 const parse = relativePointer => {
   const match = relativePointer.match(relativeJsonPointerRegExp);
   if (match === null || typeof match.groups === 'undefined') {
-    throw new InvalidRelativeJsonPointerError(relativePointer);
+    throw new InvalidRelativeJsonPointerError(`Invalid Relative JSON Pointer "${relativePointer}".`, {
+      relativePointer
+    });
+  }
+  try {
+    // non-negative-integer
+    const nonNegativeIntegerPrefix = parseInt(match.groups.nonNegativeIntegerPrefix, 10);
+    // index-manipulation
+    const indexManipulation = typeof match.groups.indexManipulation === 'string' ? parseInt(match.groups.indexManipulation, 10) : undefined;
+    // <json-pointer>
+    const jsonPointerTokens = typeof match.groups.jsonPointer === 'string' ? parseJsonPointer(match.groups.jsonPointer) : undefined;
+    // "#"
+    const hashCharacter = typeof match.groups.hashCharacter === 'string';
+    return {
+      nonNegativeIntegerPrefix,
+      indexManipulation,
+      jsonPointerTokens,
+      hashCharacter
+    };
+  } catch (error) {
+    throw new InvalidRelativeJsonPointerError(`Relative JSON Pointer parsing of "${relativePointer}" encountered an error.`, {
+      relativePointer,
+      cause: error
+    });
   }
-
-  // non-negative-integer
-  const nonNegativeIntegerPrefix = parseInt(match.groups.nonNegativeIntegerPrefix, 10);
-  // index-manipulation
-  const indexManipulation = typeof match.groups.indexManipulation === 'string' ? parseInt(match.groups.indexManipulation, 10) : undefined;
-  // <json-pointer>
-  const jsonPointerTokens = typeof match.groups.jsonPointer === 'string' ? parseJsonPointer(match.groups.jsonPointer) : undefined;
-  // "#"
-  const hashCharacter = typeof match.groups.hashCharacter === 'string';
-  return {
-    nonNegativeIntegerPrefix,
-    indexManipulation,
-    jsonPointerTokens,
-    hashCharacter
-  };
 };
 export default parse;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swagger-api/apidom-json-pointer-relative",
-  "version": "0.75.0",
+  "version": "0.76.0",
   "description": "Evaluate Relative JSON Pointer expressions against ApiDOM.",
   "publishConfig": {
     "access": "public",
@@ -38,8 +38,9 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@babel/runtime-corejs3": "^7.20.7",
-    "@swagger-api/apidom-core": "^0.75.0",
-    "@swagger-api/apidom-json-pointer": "^0.75.0",
+    "@swagger-api/apidom-core": "^0.76.0",
+    "@swagger-api/apidom-error": "^0.76.0",
+    "@swagger-api/apidom-json-pointer": "^0.76.0",
     "@types/ramda": "~0.29.3",
     "ramda": "~0.29.0",
     "ramda-adjunct": "^4.0.0"
@@ -54,5 +55,5 @@
     "README.md",
     "CHANGELOG.md"
   ],
-  "gitHead": "1be099d8de39f3fb703cbb5e3f59076e1110fd9b"
+  "gitHead": "ce497d1083df34162b9cf2047d6cbd8843af3314"
 }

package/types/dist.d.ts

@@ -1,5 +1,34 @@
+import { ApiDOMStructuredError, ApiDOMErrorOptions } from '@swagger-api/apidom-error';
 import { Element } from '@swagger-api/apidom-core';
 
+declare class RelativeJsonPointerError extends ApiDOMStructuredError {
+}
+
+interface InvalidRelativeJsonPointerErrorOptions extends ApiDOMErrorOptions {
+    readonly relativePointer: string;
+}
+declare class InvalidRelativeJsonPointerError extends RelativeJsonPointerError {
+    readonly relativePointer: string;
+    constructor(message?: string, structuredOptions?: InvalidRelativeJsonPointerErrorOptions);
+}
+
+interface EvaluationRelativeJsonPointerErrorOptions<T extends Element, U extends Element, V extends Element> extends ApiDOMErrorOptions {
+    readonly relativePointer: string;
+    readonly currentElement: T;
+    readonly rootElement: U;
+    readonly cursorElement?: V;
+}
+declare class EvaluationRelativeJsonPointerError<T extends Element, U extends Element, V extends Element> extends RelativeJsonPointerError {
+    readonly relativePointer: string;
+    readonly currentElement: string;
+    readonly currentElementSourceMap?: [[number, number, number], [number, number, number]];
+    readonly rootElement: string;
+    readonly rootElementSourceMap?: [[number, number, number], [number, number, number]];
+    readonly cursorElement?: string;
+    readonly cursorElementSourceMap?: [[number, number, number], [number, number, number]];
+    constructor(message?: string, structuredOptions?: EvaluationRelativeJsonPointerErrorOptions<T, U, V>);
+}
+
 type RelativeJsonPointer = {
     readonly nonNegativeIntegerPrefix: number;
     readonly indexManipulation?: number;
@@ -7,6 +36,17 @@ type RelativeJsonPointer = {
     readonly hashCharacter?: boolean;
 };
 
+interface CompilationRelativeJsonPointerErrorOptions extends ApiDOMErrorOptions {
+    readonly relativePointer: RelativeJsonPointer;
+}
+declare class CompilationRelativeJsonPointerError extends RelativeJsonPointerError {
+    readonly nonNegativeIntegerPrefix: number;
+    readonly indexManipulation?: number;
+    readonly jsonPointerTokens?: string[];
+    readonly hashCharacter?: boolean;
+    constructor(message?: string, structuredOptions?: CompilationRelativeJsonPointerErrorOptions);
+}
+
 declare const isRelativeJsonPointer: (value: any) => boolean;
 declare const parse: (relativePointer: string) => RelativeJsonPointer;
 
@@ -14,11 +54,4 @@ declare const compile: (relativeJsonPointer: RelativeJsonPointer) => string;
 
 declare const evaluate: <T extends Element, U extends Element>(relativePointer: string, currentElement: T, rootElement: U) => Element;
 
-declare class EvaluationRelativeJsonPointerError extends Error {
-}
-
-declare class InvalidRelativeJsonPointerError extends Error {
-    constructor(relativePointer: string);
-}
-
-export { EvaluationRelativeJsonPointerError, InvalidRelativeJsonPointerError, compile, evaluate, isRelativeJsonPointer, parse };
+export { CompilationRelativeJsonPointerError, CompilationRelativeJsonPointerErrorOptions, EvaluationRelativeJsonPointerError, EvaluationRelativeJsonPointerErrorOptions, InvalidRelativeJsonPointerError, InvalidRelativeJsonPointerErrorOptions, RelativeJsonPointer, RelativeJsonPointerError, compile, evaluate, isRelativeJsonPointer, parse };

package/cjs/errors/index.cjs

@@ -1,9 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
-exports.__esModule = true;
-exports.InvalidRelativeJsonPointerError = exports.EvaluationRelativeJsonPointerError = void 0;
-var _EvaluationRelativeJsonPointerError = _interopRequireDefault(require("./EvaluationRelativeJsonPointerError.cjs"));
-exports.EvaluationRelativeJsonPointerError = _EvaluationRelativeJsonPointerError.default;
-var _InvalidRelativeJsonPointerError = _interopRequireDefault(require("./InvalidRelativeJsonPointerError.cjs"));
-exports.InvalidRelativeJsonPointerError = _InvalidRelativeJsonPointerError.default;

package/es/errors/index.js

@@ -1,2 +0,0 @@
-export { default as EvaluationRelativeJsonPointerError } from "./EvaluationRelativeJsonPointerError.js";
-export { default as InvalidRelativeJsonPointerError } from "./InvalidRelativeJsonPointerError.js";