@speclynx/apidom-json-path 2.0.1 → 2.2.0

package/src/index.mjs

@@ -1,4 +1,65 @@
-export { default as EvaluationJsonPathError } from "./errors/EvaluationJsonPathError.mjs";
-export { default as MultiEvaluationJsonPathError } from "./errors/MultiEvaluationJsonPathError.mjs";
-export { default as evaluate } from "./evaluate.mjs";
-export { default as evaluateMulti } from "./evaluate-multi.mjs";
+import { evaluate as baseEvaluate } from '@swaggerexpert/jsonpath';
+export {
+/**
+ * Parsing
+ */
+parse, CSTTranslator, CSTOptimizedTranslator, ASTTranslator, XMLTranslator,
+/**
+ * Testing
+ */
+test,
+/**
+ * Normalized Path
+ */
+NormalizedPath,
+/**
+ * Evaluation
+ */
+functions, EvaluationRealm, JSONEvaluationRealm,
+/**
+ * Grammar
+ */
+Grammar,
+/**
+ * Errors
+ */
+JSONPathError, JSONPathParseError, JSONNormalizedPathError, JSONPathEvaluateError } from '@swaggerexpert/jsonpath';
+import ApiDOMEvaluationRealm from "./realm.mjs";
+export { ApiDOMEvaluationRealm };
+const realm = new ApiDOMEvaluationRealm();
+
+/**
+ * Options for ApiDOM JSONPath evaluation.
+ * @public
+ */
+
+/**
+ * Evaluate a JSONPath expression against an ApiDOM element.
+ *
+ * @param value - ApiDOM element to query
+ * @param expression - JSONPath expression
+ * @param options - Evaluation options
+ * @returns Array of matched values
+ *
+ * @example
+ * ```typescript
+ * import { ObjectElement } from '@speclynx/apidom-datamodel';
+ * import { evaluate } from '@speclynx/apidom-json-path';
+ *
+ * const element = new ObjectElement({ a: { b: [1, 2, 3] } });
+ * const results = evaluate(element, '$.a.b[*]');
+ * // => [NumberElement(1), NumberElement(2), NumberElement(3)]
+ * ```
+ *
+ * @public
+ */
+export const evaluate = (value, expression, options = {}) => {
+  return baseEvaluate(value, expression, {
+    ...options,
+    realm
+  });
+};
+
+/**
+ * Re-export all types
+ */

package/src/realm.cjs

@@ -0,0 +1,148 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _apidomDatamodel = require("@speclynx/apidom-datamodel");
+var _jsonpath = require("@swaggerexpert/jsonpath");
+/**
+ * ApiDOM Evaluation Realm implementation for JSONPath.
+ * @public
+ */
+class ApiDOMEvaluationRealm extends _jsonpath.EvaluationRealm {
+  name = 'apidom';
+  isObject(value) {
+    return (0, _apidomDatamodel.isObjectElement)(value);
+  }
+  isArray(value) {
+    return (0, _apidomDatamodel.isArrayElement)(value);
+  }
+  isString(value) {
+    return (0, _apidomDatamodel.isStringElement)(value);
+  }
+  isNumber(value) {
+    return (0, _apidomDatamodel.isNumberElement)(value);
+  }
+  isBoolean(value) {
+    return (0, _apidomDatamodel.isBooleanElement)(value);
+  }
+  isNull(value) {
+    return (0, _apidomDatamodel.isNullElement)(value);
+  }
+  getString(value) {
+    if ((0, _apidomDatamodel.isStringElement)(value)) return value.toValue();
+    if (typeof value === 'string') return value;
+    return undefined;
+  }
+  getProperty(value, key) {
+    if (!(0, _apidomDatamodel.isObjectElement)(value)) return undefined;
+    if (!value.hasKey(key)) return undefined;
+    return value.get(key);
+  }
+  hasProperty(value, key) {
+    if (!(0, _apidomDatamodel.isObjectElement)(value)) return false;
+    return value.hasKey(key);
+  }
+  getElement(value, index) {
+    if (!(0, _apidomDatamodel.isArrayElement)(value)) return undefined;
+    if (index < 0 || index >= value.length) return undefined;
+    return value.get(index);
+  }
+  getKeys(value) {
+    if (!(0, _apidomDatamodel.isObjectElement)(value)) return [];
+    return value.keys();
+  }
+  getLength(value) {
+    if ((0, _apidomDatamodel.isStringElement)(value)) return [...value.toValue()].length;
+    if ((0, _apidomDatamodel.isArrayElement)(value)) return value.length;
+    if ((0, _apidomDatamodel.isObjectElement)(value)) return value.length;
+    if (typeof value === 'string') return [...value].length;
+    if (Array.isArray(value)) return value.length;
+    return 0;
+  }
+  *entries(value) {
+    if ((0, _apidomDatamodel.isArrayElement)(value)) {
+      let index = 0;
+      for (const item of value) {
+        yield [index, item];
+        index += 1;
+      }
+    } else if ((0, _apidomDatamodel.isObjectElement)(value)) {
+      for (const member of value) {
+        yield [member.key.toValue(), member.value];
+      }
+    }
+  }
+  compare(left, operator, right) {
+    // Handle Nothing (undefined) comparisons
+    if (left === undefined || right === undefined) {
+      if (operator === '==') return left === undefined && right === undefined;
+      if (operator === '!=') return !(left === undefined && right === undefined);
+      return false;
+    }
+
+    // Check if both are numbers (elements or primitives)
+    const leftIsNumber = (0, _apidomDatamodel.isNumberElement)(left) || typeof left === 'number';
+    const rightIsNumber = (0, _apidomDatamodel.isNumberElement)(right) || typeof right === 'number';
+
+    // For numeric values, use primitive comparison with -0 normalization (RFC 9535)
+    if (leftIsNumber && rightIsNumber) {
+      const leftPrimitive = (0, _apidomDatamodel.isNumberElement)(left) ? left.toValue() : left;
+      const rightPrimitive = (0, _apidomDatamodel.isNumberElement)(right) ? right.toValue() : right;
+      const leftVal = Object.is(leftPrimitive, -0) ? 0 : leftPrimitive;
+      const rightVal = Object.is(rightPrimitive, -0) ? 0 : rightPrimitive;
+      switch (operator) {
+        case '==':
+          return leftVal === rightVal;
+        case '!=':
+          return leftVal !== rightVal;
+        case '<':
+          return leftVal < rightVal;
+        case '>':
+          return leftVal > rightVal;
+        case '<=':
+          return leftVal <= rightVal;
+        case '>=':
+          return leftVal >= rightVal;
+        default:
+          return false;
+      }
+    }
+
+    // Check if both are strings (elements or primitives)
+    const leftIsString = (0, _apidomDatamodel.isStringElement)(left) || typeof left === 'string';
+    const rightIsString = (0, _apidomDatamodel.isStringElement)(right) || typeof right === 'string';
+
+    // For string values, use primitive comparison
+    if (leftIsString && rightIsString) {
+      const leftVal = (0, _apidomDatamodel.isStringElement)(left) ? left.toValue() : left;
+      const rightVal = (0, _apidomDatamodel.isStringElement)(right) ? right.toValue() : right;
+      switch (operator) {
+        case '==':
+          return leftVal === rightVal;
+        case '!=':
+          return leftVal !== rightVal;
+        case '<':
+          return leftVal < rightVal;
+        case '>':
+          return leftVal > rightVal;
+        case '<=':
+          return leftVal <= rightVal;
+        case '>=':
+          return leftVal >= rightVal;
+        default:
+          return false;
+      }
+    }
+
+    // For other types (booleans, nulls), only equality operators are defined (RFC 9535)
+    if (operator === '==') {
+      return (0, _apidomDatamodel.refract)(left).equals(right);
+    }
+    if (operator === '!=') {
+      return !(0, _apidomDatamodel.refract)(left).equals(right);
+    }
+    // Comparison operators (<, >, <=, >=) are not defined for non-numeric, non-string types
+    return false;
+  }
+}
+var _default = exports.default = ApiDOMEvaluationRealm;

package/src/realm.mjs

@@ -0,0 +1,145 @@
+import { isObjectElement, isArrayElement, isStringElement, isNumberElement, isBooleanElement, isNullElement, refract } from '@speclynx/apidom-datamodel';
+import { EvaluationRealm } from '@swaggerexpert/jsonpath';
+
+/**
+ * ApiDOM Evaluation Realm implementation for JSONPath.
+ * @public
+ */
+class ApiDOMEvaluationRealm extends EvaluationRealm {
+  name = 'apidom';
+  isObject(value) {
+    return isObjectElement(value);
+  }
+  isArray(value) {
+    return isArrayElement(value);
+  }
+  isString(value) {
+    return isStringElement(value);
+  }
+  isNumber(value) {
+    return isNumberElement(value);
+  }
+  isBoolean(value) {
+    return isBooleanElement(value);
+  }
+  isNull(value) {
+    return isNullElement(value);
+  }
+  getString(value) {
+    if (isStringElement(value)) return value.toValue();
+    if (typeof value === 'string') return value;
+    return undefined;
+  }
+  getProperty(value, key) {
+    if (!isObjectElement(value)) return undefined;
+    if (!value.hasKey(key)) return undefined;
+    return value.get(key);
+  }
+  hasProperty(value, key) {
+    if (!isObjectElement(value)) return false;
+    return value.hasKey(key);
+  }
+  getElement(value, index) {
+    if (!isArrayElement(value)) return undefined;
+    if (index < 0 || index >= value.length) return undefined;
+    return value.get(index);
+  }
+  getKeys(value) {
+    if (!isObjectElement(value)) return [];
+    return value.keys();
+  }
+  getLength(value) {
+    if (isStringElement(value)) return [...value.toValue()].length;
+    if (isArrayElement(value)) return value.length;
+    if (isObjectElement(value)) return value.length;
+    if (typeof value === 'string') return [...value].length;
+    if (Array.isArray(value)) return value.length;
+    return 0;
+  }
+  *entries(value) {
+    if (isArrayElement(value)) {
+      let index = 0;
+      for (const item of value) {
+        yield [index, item];
+        index += 1;
+      }
+    } else if (isObjectElement(value)) {
+      for (const member of value) {
+        yield [member.key.toValue(), member.value];
+      }
+    }
+  }
+  compare(left, operator, right) {
+    // Handle Nothing (undefined) comparisons
+    if (left === undefined || right === undefined) {
+      if (operator === '==') return left === undefined && right === undefined;
+      if (operator === '!=') return !(left === undefined && right === undefined);
+      return false;
+    }
+
+    // Check if both are numbers (elements or primitives)
+    const leftIsNumber = isNumberElement(left) || typeof left === 'number';
+    const rightIsNumber = isNumberElement(right) || typeof right === 'number';
+
+    // For numeric values, use primitive comparison with -0 normalization (RFC 9535)
+    if (leftIsNumber && rightIsNumber) {
+      const leftPrimitive = isNumberElement(left) ? left.toValue() : left;
+      const rightPrimitive = isNumberElement(right) ? right.toValue() : right;
+      const leftVal = Object.is(leftPrimitive, -0) ? 0 : leftPrimitive;
+      const rightVal = Object.is(rightPrimitive, -0) ? 0 : rightPrimitive;
+      switch (operator) {
+        case '==':
+          return leftVal === rightVal;
+        case '!=':
+          return leftVal !== rightVal;
+        case '<':
+          return leftVal < rightVal;
+        case '>':
+          return leftVal > rightVal;
+        case '<=':
+          return leftVal <= rightVal;
+        case '>=':
+          return leftVal >= rightVal;
+        default:
+          return false;
+      }
+    }
+
+    // Check if both are strings (elements or primitives)
+    const leftIsString = isStringElement(left) || typeof left === 'string';
+    const rightIsString = isStringElement(right) || typeof right === 'string';
+
+    // For string values, use primitive comparison
+    if (leftIsString && rightIsString) {
+      const leftVal = isStringElement(left) ? left.toValue() : left;
+      const rightVal = isStringElement(right) ? right.toValue() : right;
+      switch (operator) {
+        case '==':
+          return leftVal === rightVal;
+        case '!=':
+          return leftVal !== rightVal;
+        case '<':
+          return leftVal < rightVal;
+        case '>':
+          return leftVal > rightVal;
+        case '<=':
+          return leftVal <= rightVal;
+        case '>=':
+          return leftVal >= rightVal;
+        default:
+          return false;
+      }
+    }
+
+    // For other types (booleans, nulls), only equality operators are defined (RFC 9535)
+    if (operator === '==') {
+      return refract(left).equals(right);
+    }
+    if (operator === '!=') {
+      return !refract(left).equals(right);
+    }
+    // Comparison operators (<, >, <=, >=) are not defined for non-numeric, non-string types
+    return false;
+  }
+}
+export default ApiDOMEvaluationRealm;

package/types/apidom-json-path.d.ts

@@ -1,78 +1,114 @@
-import { ApiDOMErrorOptions } from '@speclynx/apidom-error';
-import { ApiDOMStructuredError } from '@speclynx/apidom-error';
-import { Element as Element_2 } from '@speclynx/apidom-datamodel';
+import { ArrayElement } from '@speclynx/apidom-datamodel';
+import { ASTTranslator } from '@swaggerexpert/jsonpath';
+import { CSTOptimizedTranslator } from '@swaggerexpert/jsonpath';
+import { CSTTranslator } from '@swaggerexpert/jsonpath';
+import { EvaluationRealm } from '@swaggerexpert/jsonpath';
+import { functions } from '@swaggerexpert/jsonpath';
+import { Grammar } from '@swaggerexpert/jsonpath';
+import { JSONEvaluationRealm } from '@swaggerexpert/jsonpath';
+import { JSONNormalizedPathError } from '@swaggerexpert/jsonpath';
+import { JSONPathError } from '@swaggerexpert/jsonpath';
+import { JSONPathEvaluateError } from '@swaggerexpert/jsonpath';
+import { JSONPathParseError } from '@swaggerexpert/jsonpath';
+import { NormalizedPath } from '@swaggerexpert/jsonpath';
+import { ObjectElement } from '@speclynx/apidom-datamodel';
+import { parse } from '@swaggerexpert/jsonpath';
+import { test as test_2 } from '@swaggerexpert/jsonpath';
+import { XMLTranslator } from '@swaggerexpert/jsonpath';
 
 /**
+ * Options for ApiDOM JSONPath evaluation.
  * @public
  */
-export declare type Evaluate = {
-    <T extends Element_2>(path: string, element: T): Element_2[];
-    <T extends Element_2>(path: string[], element: T): Element_2[];
-};
+export declare interface ApiDOMEvaluateOptions {
+    /**
+     * Optional callback called for each match.
+     * @param value - The matched value
+     * @param normalizedPath - The normalized path to the match
+     */
+    callback?: (value: unknown, normalizedPath: string) => void;
+    /**
+     * Optional custom function registry.
+     * Can extend or override built-in functions (length, count, match, search, value).
+     */
+    functions?: Record<string, (...args: unknown[]) => unknown>;
+}
 
 /**
- * Evaluates single JSONPath on ApiDOM element.
+ * ApiDOM Evaluation Realm implementation for JSONPath.
  * @public
  */
-export declare const evaluate: Evaluate;
+export declare class ApiDOMEvaluationRealm extends EvaluationRealm {
+    name: string;
+    isObject(value: unknown): value is ObjectElement;
+    isArray(value: unknown): value is ArrayElement;
+    isString(value: unknown): boolean;
+    isNumber(value: unknown): boolean;
+    isBoolean(value: unknown): boolean;
+    isNull(value: unknown): boolean;
+    getString(value: unknown): string | undefined;
+    getProperty(value: unknown, key: string): unknown;
+    hasProperty(value: unknown, key: string): boolean;
+    getElement(value: unknown, index: number): unknown;
+    getKeys(value: unknown): string[];
+    getLength(value: unknown): number;
+    entries(value: unknown): Iterable<[string | number, unknown]>;
+    compare(left: unknown, operator: string, right: unknown): boolean;
+}
 
-/**
- * @public
- */
-export declare type EvaluateMulti = {
-    <T extends Element_2>(paths: string[], element: T): JSONPathEvalTuple[];
-    <T extends Element_2>(paths: string[][], element: T): JSONPathEvalTuple[];
-};
+export { ASTTranslator }
 
-/**
- * Evaluates multiple JSONPaths on ApiDOM element.
- * @public
- */
-export declare const evaluateMulti: EvaluateMulti;
+export { CSTOptimizedTranslator }
 
-/**
- * @public
- */
-export declare class EvaluationJsonPathError<T extends Element_2> extends JsonPathError {
-    readonly path: string | string[];
-    readonly element: T;
-    constructor(message?: string, structuredOptions?: EvaluationJsonPathErrorOptions<T>);
-}
+export { CSTTranslator }
 
 /**
+ * Evaluate a JSONPath expression against an ApiDOM element.
+ *
+ * @param value - ApiDOM element to query
+ * @param expression - JSONPath expression
+ * @param options - Evaluation options
+ * @returns Array of matched values
+ *
+ * @example
+ * ```typescript
+ * import { ObjectElement } from '@speclynx/apidom-datamodel';
+ * import { evaluate } from '@speclynx/apidom-json-path';
+ *
+ * const element = new ObjectElement({ a: { b: [1, 2, 3] } });
+ * const results = evaluate(element, '$.a.b[*]');
+ * // => [NumberElement(1), NumberElement(2), NumberElement(3)]
+ * ```
+ *
  * @public
  */
-export declare interface EvaluationJsonPathErrorOptions<T extends Element_2> extends ApiDOMErrorOptions {
-    path: string | string[];
-    element: T;
-}
+export declare const evaluate: <T = unknown>(value: unknown, expression: string, options?: ApiDOMEvaluateOptions) => T[];
 
-/**
- * @public
- */
-export declare class JsonPathError extends ApiDOMStructuredError {
-}
+export { EvaluationRealm }
 
-/**
- * @public
- */
-export declare type JSONPathEvalTuple = [string, Element_2[]];
+export { functions }
 
-/**
- * @public
- */
-export declare class MultiEvaluationJsonPathError<T extends Element_2> extends JsonPathError {
-    readonly paths: string[] | string[][];
-    readonly element: T;
-    constructor(message?: string, structuredOptions?: MultiEvaluationJsonPathErrorOptions<T>);
-}
+export { Grammar }
 
-/**
- * @public
- */
-export declare interface MultiEvaluationJsonPathErrorOptions<T extends Element_2> extends ApiDOMErrorOptions {
-    paths: string[] | string[][];
-    element: T;
-}
+export { JSONEvaluationRealm }
+
+export { JSONNormalizedPathError }
+
+export { JSONPathError }
+
+export { JSONPathEvaluateError }
+
+export { JSONPathParseError }
+
+export { NormalizedPath }
+
+export { parse }
+
+export { test_2 as test }
+
+export { XMLTranslator }
+
+
+export * from "@swaggerexpert/jsonpath";
 
 export { }

package/src/errors/EvaluationJsonPathError.cjs

@@ -1,25 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
-exports.__esModule = true;
-exports.default = void 0;
-var _JsonPathError = _interopRequireDefault(require("./JsonPathError.cjs"));
-/**
- * @public
- */
-
-/**
- * @public
- */
-class EvaluationJsonPathError extends _JsonPathError.default {
-  path;
-  element;
-  constructor(message, structuredOptions) {
-    super(message, structuredOptions);
-    if (typeof structuredOptions !== 'undefined') {
-      this.path = structuredOptions.path;
-      this.element = structuredOptions.element;
-    }
-  }
-}
-var _default = exports.default = EvaluationJsonPathError;

package/src/errors/EvaluationJsonPathError.mjs

@@ -1,19 +0,0 @@
-import JsonPathError from "./JsonPathError.mjs";
-/**
- * @public
- */
-/**
- * @public
- */
-class EvaluationJsonPathError extends JsonPathError {
-  path;
-  element;
-  constructor(message, structuredOptions) {
-    super(message, structuredOptions);
-    if (typeof structuredOptions !== 'undefined') {
-      this.path = structuredOptions.path;
-      this.element = structuredOptions.element;
-    }
-  }
-}
-export default EvaluationJsonPathError;

package/src/errors/JsonPathError.cjs

@@ -1,10 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.default = void 0;
-var _apidomError = require("@speclynx/apidom-error");
-/**
- * @public
- */
-class JsonPathError extends _apidomError.ApiDOMStructuredError {}
-var _default = exports.default = JsonPathError;

package/src/errors/JsonPathError.mjs

@@ -1,7 +0,0 @@
-import { ApiDOMStructuredError } from '@speclynx/apidom-error';
-
-/**
- * @public
- */
-class JsonPathError extends ApiDOMStructuredError {}
-export default JsonPathError;

package/src/errors/MultiEvaluationJsonPathError.cjs

@@ -1,25 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
-exports.__esModule = true;
-exports.default = void 0;
-var _JsonPathError = _interopRequireDefault(require("./JsonPathError.cjs"));
-/**
- * @public
- */
-
-/**
- * @public
- */
-class MultiEvaluationJsonPathError extends _JsonPathError.default {
-  paths;
-  element;
-  constructor(message, structuredOptions) {
-    super(message, structuredOptions);
-    if (typeof structuredOptions !== 'undefined') {
-      this.paths = structuredOptions.paths;
-      this.element = structuredOptions.element;
-    }
-  }
-}
-var _default = exports.default = MultiEvaluationJsonPathError;

package/src/errors/MultiEvaluationJsonPathError.mjs

@@ -1,19 +0,0 @@
-import JsonPathError from "./JsonPathError.mjs";
-/**
- * @public
- */
-/**
- * @public
- */
-class MultiEvaluationJsonPathError extends JsonPathError {
-  paths;
-  element;
-  constructor(message, structuredOptions) {
-    super(message, structuredOptions);
-    if (typeof structuredOptions !== 'undefined') {
-      this.paths = structuredOptions.paths;
-      this.element = structuredOptions.element;
-    }
-  }
-}
-export default MultiEvaluationJsonPathError;