@speclynx/apidom-json-path 4.0.2 → 4.0.4

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [4.0.4](https://github.com/speclynx/apidom/compare/v4.0.3...v4.0.4) (2026-03-12)
+
+### Bug Fixes
+
+- **release:** override minimatch 10.2.3 to fix glob pattern regression in lerna publish ([#157](https://github.com/speclynx/apidom/issues/157)) ([c2d65a0](https://github.com/speclynx/apidom/commit/c2d65a06a2187e8563a9dc9db74ba27255450e0b)), closes [lerna/lerna#4305](https://github.com/lerna/lerna/issues/4305) [isaacs/minimatch#284](https://github.com/isaacs/minimatch/issues/284)
+
+## [4.0.3](https://github.com/speclynx/apidom/compare/v4.0.2...v4.0.3) (2026-03-11)
+
+### Bug Fixes
+
+- **release:** fix v4.0.2 failed release ([b4dc1c4](https://github.com/speclynx/apidom/commit/b4dc1c48e8d9b2986a70e49b5554eb0a166d7528))
+
 ## [4.0.2](https://github.com/speclynx/apidom/compare/v4.0.1...v4.0.2) (2026-03-11)
 
 **Note:** Version bump only for package @speclynx/apidom-json-path

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@speclynx/apidom-json-path",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "description": "Evaluate JSONPath expressions against ApiDOM.",
   "keywords": [
     "apidom",
@@ -55,8 +55,8 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@babel/runtime-corejs3": "^7.28.4",
-    "@speclynx/apidom-datamodel": "4.0.2",
-    "@speclynx/apidom-error": "4.0.2",
+    "@speclynx/apidom-datamodel": "4.0.4",
+    "@speclynx/apidom-error": "4.0.4",
     "@swaggerexpert/jsonpath": "^4.0.3"
   },
   "files": [
@@ -69,5 +69,5 @@
     "README.md",
     "CHANGELOG.md"
   ],
-  "gitHead": "af1b05d4d5e48a11a3a03cd5699324e0f1b62765"
+  "gitHead": "a06f6ef3d37ad5bf860cbbf4b442bfbe3a522cc2"
 }

package/src/index.cjs

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.test = exports.parse = exports.functions = exports.evaluate = exports.XMLTranslator = exports.NormalizedPath = exports.JSONPathParseError = exports.JSONPathEvaluateError = exports.JSONPathError = exports.JSONNormalizedPathError = exports.JSONEvaluationRealm = exports.Grammar = exports.EvaluationRealm = exports.CSTTranslator = exports.CSTOptimizedTranslator = exports.ASTTranslator = void 0;
+var _jsonpath = require("@swaggerexpert/jsonpath");
+exports.parse = _jsonpath.parse;
+exports.CSTTranslator = _jsonpath.CSTTranslator;
+exports.CSTOptimizedTranslator = _jsonpath.CSTOptimizedTranslator;
+exports.ASTTranslator = _jsonpath.ASTTranslator;
+exports.XMLTranslator = _jsonpath.XMLTranslator;
+exports.test = _jsonpath.test;
+exports.NormalizedPath = _jsonpath.NormalizedPath;
+exports.functions = _jsonpath.functions;
+exports.EvaluationRealm = _jsonpath.EvaluationRealm;
+exports.JSONEvaluationRealm = _jsonpath.JSONEvaluationRealm;
+exports.Grammar = _jsonpath.Grammar;
+exports.JSONPathError = _jsonpath.JSONPathError;
+exports.JSONPathParseError = _jsonpath.JSONPathParseError;
+exports.JSONNormalizedPathError = _jsonpath.JSONNormalizedPathError;
+exports.JSONPathEvaluateError = _jsonpath.JSONPathEvaluateError;
+var _realm = _interopRequireDefault(require("./realm.cjs"));
+exports.ApiDOMEvaluationRealm = _realm.default;
+const realm = new _realm.default();
+
+/**
+ * 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
+ */
+const evaluate = (value, expression, options = {}) => {
+  return (0, _jsonpath.evaluate)(value, expression, {
+    ...options,
+    realm
+  });
+};
+
+/**
+ * Re-export all types
+ */
+exports.evaluate = evaluate;

package/src/index.mjs

@@ -0,0 +1,65 @@
+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;