@swaggerexpert/jsonpath 3.2.3 → 3.2.5

package/cjs/parse/translators/CSTOptimizedTranslator.cjs

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _CSTTranslator = _interopRequireDefault(require("./CSTTranslator.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class CSTOptimizedTranslator extends _CSTTranslator.default {
+  collapsibleTypes = ['single-quoted', 'double-quoted', 'normal-single-quoted'];
+  droppableTypes = ['text', 'segments', 'singular-query-segments'];
+  constructor({
+    collapsibleTypes,
+    droppableTypes
+  } = {}) {
+    super();
+    if (Array.isArray(collapsibleTypes)) {
+      this.collapsibleTypes = collapsibleTypes;
+    }
+    if (Array.isArray(droppableTypes)) {
+      this.droppableTypes = droppableTypes;
+    }
+  }
+  getTree() {
+    const options = {
+      optimize: true,
+      collapsibleTypes: this.collapsibleTypes,
+      droppableTypes: this.droppableTypes
+    };
+    const data = {
+      stack: [],
+      root: null,
+      options
+    };
+    this.translate(data);
+    delete data.stack;
+    delete data.options;
+    return data;
+  }
+}
+var _default = exports.default = CSTOptimizedTranslator;

package/cjs/parse/translators/CSTTranslator.cjs

@@ -0,0 +1,118 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _apgLite = require("../../apg-lite.cjs");
+var _cst = _interopRequireDefault(require("../callbacks/cst.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class CSTTranslator extends _apgLite.Ast {
+  constructor() {
+    super();
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.1.1
+    this.callbacks['jsonpath-query'] = (0, _cst.default)('jsonpath-query');
+    this.callbacks['segments'] = (0, _cst.default)('segments');
+    this.callbacks['B'] = (0, _cst.default)('text');
+    this.callbacks['S'] = (0, _cst.default)('text');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.2.1
+    this.callbacks['root-identifier'] = (0, _cst.default)('root-identifier');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3
+    this.callbacks['selector'] = (0, _cst.default)('selector');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3.1.1
+    this.callbacks['name-selector'] = (0, _cst.default)('name-selector');
+    this.callbacks['string-literal'] = (0, _cst.default)('string-literal');
+    this.callbacks['double-quoted'] = (0, _cst.default)('double-quoted');
+    this.callbacks['single-quoted'] = (0, _cst.default)('single-quoted');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3.2.1
+    this.callbacks['wildcard-selector'] = (0, _cst.default)('wildcard-selector');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3.3.1
+    this.callbacks['index-selector'] = (0, _cst.default)('index-selector');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3.4.1
+    this.callbacks['slice-selector'] = (0, _cst.default)('slice-selector');
+    this.callbacks['start'] = (0, _cst.default)('start');
+    this.callbacks['end'] = (0, _cst.default)('end');
+    this.callbacks['step'] = (0, _cst.default)('step');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3.5.1
+    this.callbacks['filter-selector'] = (0, _cst.default)('filter-selector');
+    this.callbacks['logical-expr'] = (0, _cst.default)('logical-expr');
+    this.callbacks['logical-or-expr'] = (0, _cst.default)('logical-or-expr');
+    this.callbacks['logical-and-expr'] = (0, _cst.default)('logical-and-expr');
+    this.callbacks['basic-expr'] = (0, _cst.default)('basic-expr');
+    this.callbacks['paren-expr'] = (0, _cst.default)('paren-expr');
+    this.callbacks['logical-not-op'] = (0, _cst.default)('logical-not-op');
+    this.callbacks['test-expr'] = (0, _cst.default)('test-expr');
+    this.callbacks['filter-query'] = (0, _cst.default)('filter-query');
+    this.callbacks['rel-query'] = (0, _cst.default)('rel-query');
+    this.callbacks['current-node-identifier'] = (0, _cst.default)('current-node-identifier');
+    this.callbacks['comparison-expr'] = (0, _cst.default)('comparison-expr');
+    this.callbacks['literal'] = (0, _cst.default)('literal');
+    this.callbacks['comparable'] = (0, _cst.default)('comparable');
+    this.callbacks['comparison-op'] = (0, _cst.default)('comparison-op');
+    this.callbacks['singular-query'] = (0, _cst.default)('singular-query');
+    this.callbacks['rel-singular-query'] = (0, _cst.default)('rel-singular-query');
+    this.callbacks['abs-singular-query'] = (0, _cst.default)('abs-singular-query');
+    this.callbacks['singular-query-segments'] = (0, _cst.default)('singular-query-segments');
+    this.callbacks['name-segment'] = (0, _cst.default)('name-segment');
+    this.callbacks['index-segment'] = (0, _cst.default)('index-segment');
+    this.callbacks['number'] = (0, _cst.default)('number');
+    this.callbacks['true'] = (0, _cst.default)('true');
+    this.callbacks['false'] = (0, _cst.default)('false');
+    this.callbacks['null'] = (0, _cst.default)('null');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.4
+    this.callbacks['function-name'] = (0, _cst.default)('function-name');
+    this.callbacks['function-expr'] = (0, _cst.default)('function-expr');
+    this.callbacks['function-argument'] = (0, _cst.default)('function-argument');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.5
+    this.callbacks['segment'] = (0, _cst.default)('segment');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.5.1.1
+    this.callbacks['child-segment'] = (0, _cst.default)('child-segment');
+    this.callbacks['bracketed-selection'] = (0, _cst.default)('bracketed-selection');
+    this.callbacks['member-name-shorthand'] = (0, _cst.default)('member-name-shorthand');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.5.2.1
+    this.callbacks['descendant-segment'] = (0, _cst.default)('descendant-segment');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#name-normalized-paths
+    this.callbacks['normalized-path'] = (0, _cst.default)('normalized-path');
+    this.callbacks['normal-index-segment'] = (0, _cst.default)('normal-index-segment');
+    this.callbacks['normal-selector'] = (0, _cst.default)('normal-selector');
+    this.callbacks['normal-name-selector'] = (0, _cst.default)('normal-name-selector');
+    this.callbacks['normal-index-selector'] = (0, _cst.default)('normal-index-selector');
+    this.callbacks['normal-single-quoted'] = (0, _cst.default)('normal-single-quoted');
+
+    // Surrogate named rules
+    this.callbacks['dot-prefix'] = (0, _cst.default)('text');
+    this.callbacks['double-dot-prefix'] = (0, _cst.default)('text');
+    this.callbacks['left-bracket'] = (0, _cst.default)('text');
+    this.callbacks['right-bracket'] = (0, _cst.default)('text');
+    this.callbacks['comma'] = (0, _cst.default)('text');
+    this.callbacks['colon'] = (0, _cst.default)('text');
+    this.callbacks['dquote'] = (0, _cst.default)('text');
+    this.callbacks['squote'] = (0, _cst.default)('text');
+    this.callbacks['questionmark'] = (0, _cst.default)('text');
+    this.callbacks['disjunction'] = (0, _cst.default)('text');
+    this.callbacks['conjunction'] = (0, _cst.default)('text');
+    this.callbacks['left-paren'] = (0, _cst.default)('text');
+    this.callbacks['right-paren'] = (0, _cst.default)('text');
+  }
+  getTree() {
+    const data = {
+      stack: [],
+      root: null
+    };
+    this.translate(data);
+    delete data.stack;
+    return data;
+  }
+}
+var _default = exports.default = CSTTranslator;

package/cjs/parse/translators/XMLTranslator.cjs

@@ -0,0 +1,12 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _CSTTranslator = _interopRequireDefault(require("./CSTTranslator.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class XMLTranslator extends _CSTTranslator.default {
+  getTree() {
+    return this.toXml();
+  }
+}
+var _default = exports.default = XMLTranslator;

package/cjs/test/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _index = _interopRequireDefault(require("../parse/index.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const test = (jsonPath, {
+  normalized = false
+} = {}) => {
+  if (typeof jsonPath !== 'string') return false;
+  try {
+    const {
+      result
+    } = (0, _index.default)(jsonPath, {
+      normalized,
+      stats: false,
+      trace: false,
+      translator: null
+    });
+    return result.success;
+  } catch {
+    return false;
+  }
+};
+var _default = exports.default = test;

package/es/compile.mjs

@@ -0,0 +1,45 @@
+import escape from "./escape.mjs";
+import JSONPathCompileError from "./errors/JSONPathCompileError.mjs";
+/**
+ * Compiles an array of selectors into a normalized JSONPath.
+ * Follows RFC 9535 Section 2.7 normalized path format.
+ *
+ * @param {Array<string|number>} selectors - Array of name selectors (strings) or index selectors (numbers)
+ * @returns {string} A normalized JSONPath string
+ * @throws {JSONPathCompileError} If selectors is not an array or contains invalid selector types
+ *
+ * @example
+ * compile(['a', 'b', 1]) // returns "$['a']['b'][1]"
+ * compile([]) // returns "$"
+ * compile(['foo', 0, 'bar']) // returns "$['foo'][0]['bar']"
+ */
+const compile = selectors => {
+  if (!Array.isArray(selectors)) {
+    throw new JSONPathCompileError(`Selectors must be an array, got: ${typeof selectors}`, {
+      selectors
+    });
+  }
+  try {
+    const segments = selectors.map(selector => {
+      if (typeof selector === 'string') {
+        // Name selector: escape and wrap in single quotes
+        return `['${escape(selector)}']`;
+      }
+      if (typeof selector === 'number') {
+        // Index selector: must be a non-negative safe integer (RFC 9535 Section 2.1)
+        if (!Number.isSafeInteger(selector) || selector < 0) {
+          throw new TypeError(`Index selector must be a non-negative safe integer, got: ${selector}`);
+        }
+        return `[${selector}]`;
+      }
+      throw new TypeError(`Selector must be a string or non-negative integer, got: ${typeof selector}`);
+    });
+    return `$${segments.join('')}`;
+  } catch (error) {
+    throw new JSONPathCompileError('Failed to compile normalized JSONPath', {
+      cause: error,
+      selectors
+    });
+  }
+};
+export default compile;

package/es/errors/JSONPathCompileError.mjs

@@ -0,0 +1,3 @@
+import JSONPathError from "./JSONPathError.mjs";
+class JSONPathCompileError extends JSONPathError {}
+export default JSONPathCompileError;

package/es/errors/JSONPathError.mjs

@@ -0,0 +1,40 @@
+class JSONPathError extends Error {
+  constructor(message, options = undefined) {
+    super(message, options);
+    this.name = this.constructor.name;
+    if (typeof message === 'string') {
+      this.message = message;
+    }
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+
+    /**
+     * This needs to stay here until our minimum supported version of Node.js is >= 16.9.0.
+     * Node.js is >= 16.9.0 supports error causes natively.
+     */
+    if (options != null && typeof options === 'object' && Object.prototype.hasOwnProperty.call(options, 'cause') && !('cause' in this)) {
+      const {
+        cause
+      } = options;
+      this.cause = cause;
+      if (cause instanceof Error && 'stack' in cause) {
+        this.stack = `${this.stack}\nCAUSE: ${cause.stack}`;
+      }
+    }
+
+    /**
+     * Allows to assign arbitrary properties to the error object.
+     */
+    if (options != null && typeof options === 'object') {
+      const {
+        cause,
+        ...causelessOptions
+      } = options;
+      Object.assign(this, causelessOptions);
+    }
+  }
+}
+export default JSONPathError;

package/es/errors/JSONPathParseError.mjs

@@ -0,0 +1,3 @@
+import JSONPathError from "./JSONPathError.mjs";
+class JSONPathParseError extends JSONPathError {}
+export default JSONPathParseError;

package/es/escape.mjs

@@ -0,0 +1,55 @@
+/**
+ * Escapes a string for use in a normalized JSONPath name selector.
+ * Follows RFC 9535 Section 2.7 escaping rules for single-quoted strings.
+ *
+ * @param {string} selector - The string to escape
+ * @returns {string} The escaped string (without surrounding quotes)
+ */
+const escape = selector => {
+  if (typeof selector !== 'string') {
+    throw new TypeError('Selector must be a string');
+  }
+  let escaped = '';
+  for (const char of selector) {
+    const codePoint = char.codePointAt(0);
+    switch (codePoint) {
+      case 0x08:
+        // backspace
+        escaped += '\\b';
+        break;
+      case 0x09:
+        // horizontal tab
+        escaped += '\\t';
+        break;
+      case 0x0a:
+        // line feed
+        escaped += '\\n';
+        break;
+      case 0x0c:
+        // form feed
+        escaped += '\\f';
+        break;
+      case 0x0d:
+        // carriage return
+        escaped += '\\r';
+        break;
+      case 0x27:
+        // apostrophe '
+        escaped += "\\'";
+        break;
+      case 0x5c:
+        // backslash \
+        escaped += '\\\\';
+        break;
+      default:
+        // Other control characters (U+0000-U+001F except those handled above)
+        if (codePoint <= 0x1f) {
+          escaped += `\\u${codePoint.toString(16).padStart(4, '0')}`;
+        } else {
+          escaped += char;
+        }
+    }
+  }
+  return escaped;
+};
+export default escape;