@swaggerexpert/jsonpath 3.2.3 → 3.2.4

package/cjs/compile.cjs

@@ -0,0 +1,50 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _escape = _interopRequireDefault(require("./escape.cjs"));
+var _JSONPathCompileError = _interopRequireDefault(require("./errors/JSONPathCompileError.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * 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.default(`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 `['${(0, _escape.default)(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.default('Failed to compile normalized JSONPath', {
+      cause: error,
+      selectors
+    });
+  }
+};
+var _default = exports.default = compile;

package/cjs/errors/JSONPathCompileError.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _JSONPathError = _interopRequireDefault(require("./JSONPathError.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class JSONPathCompileError extends _JSONPathError.default {}
+var _default = exports.default = JSONPathCompileError;

package/cjs/errors/JSONPathError.cjs

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+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);
+    }
+  }
+}
+var _default = exports.default = JSONPathError;

package/cjs/errors/JSONPathParseError.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _JSONPathError = _interopRequireDefault(require("./JSONPathError.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class JSONPathParseError extends _JSONPathError.default {}
+var _default = exports.default = JSONPathParseError;

package/cjs/escape.cjs

@@ -0,0 +1,59 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+/**
+ * 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;
+};
+var _default = exports.default = escape;