json-p3 1.2.0 → 1.3.0

package/dist/json-p3.esm.js

@@ -1,5 +1,5 @@
 /*
- * json-p3 version 1.2.0
+ * json-p3 version 1.3.0
  * https://github.com/jg-rp/json-p3
  * 
  * MIT License
@@ -639,6 +639,24 @@ var index$3 = /*#__PURE__*/Object.freeze({
   resolve: resolve
 });
 
+const Nothing = Symbol.for("jsonpath.nothing");
+
+/**
+ * ValueType for JSONPath function expression tye system.
+ */
+
+/**
+ * Object passed to FilterExpression.evaluate().
+ */
+
+/**
+ * A type predicate for an object with a string property.
+ */
+function hasStringKey(value, key) {
+  return isObject(value) && Object.hasOwn(value, key);
+}
+const KEY_MARK = "\x02";
+
 /**
  * The pair of a JSON value and its location found in the target JSON value.
  */
@@ -656,7 +674,7 @@ class JSONPathNode {
   get path() {
     return (
       // eslint-disable-next-line prefer-template
-      "$" + this.location.map(s => isString(s) ? `['${s}']` : `[${s}]`).join("")
+      "$" + this.location.map(s => isString(s) ? this.decode_name_location(s) : `[${s}]`).join("")
     );
   }
 
@@ -669,6 +687,9 @@ class JSONPathNode {
     }
     return new JSONPointer(JSONPointer.encode(this.location.map(String)));
   }
+  decode_name_location(name) {
+    return name.startsWith(KEY_MARK) ? `[~'${name.slice(1).replaceAll("'", "\\'")}']` : `['${name.replaceAll("'", "\\'")}']`;
+  }
 }
 
 /**
@@ -748,23 +769,6 @@ class JSONPathNodeList {
   }
 }
 
-const Nothing = Symbol.for("jsonpath.nothing");
-
-/**
- * ValueType for JSONPath function expression tye system.
- */
-
-/**
- * Object passed to FilterExpression.evaluate().
- */
-
-/**
- * A type predicate for an object with a string property.
- */
-function hasStringKey(value, key) {
-  return isObject(value) && Object.hasOwn(value, key);
-}
-
 /**
  * Base class for all filter expressions.
  */
@@ -1167,7 +1171,8 @@ let TokenKind = /*#__PURE__*/function (TokenKind) {
   TokenKind["AND"] = "TOKEN_AND";
   TokenKind["COLON"] = "TOKEN_COLON";
   TokenKind["COMMA"] = "TOKEN_COMMA";
-  TokenKind["CURRENT"] = "TOKEN_CURRENT_NODE";
+  TokenKind["CURRENT"] = "TOKEN_CURRENT_VALUE";
+  TokenKind["CURRENT_KEY"] = "TOKEN_CURRENT_KEY";
   TokenKind["DDOT"] = "TOKEN_DDOT";
   TokenKind["DOT"] = "TOKEN_DOT";
   TokenKind["DOUBLE_QUOTE_STRING"] = "TOKEN_DOUBLE_QUOTE_STRING";
@@ -1181,7 +1186,10 @@ let TokenKind = /*#__PURE__*/function (TokenKind) {
   TokenKind["GT"] = "TOKEN_GT";
   TokenKind["INDEX"] = "TOKEN_INDEX";
   TokenKind["KEY"] = "TOKEN_KEY";
+  TokenKind["KEY_DOUBLE_QUOTE_STRING"] = "TOKEN_KEY_DOUBLE_QUOTE_STRING";
+  TokenKind["KEY_SINGLE_QUOTE_STRING"] = "TOKEN_KEY_SINGLE_QUOTE_STRING";
   TokenKind["KEYS"] = "TOKEN_KEYS";
+  TokenKind["KEYS_FILTER"] = "TOKEN_KEYS_FILTER";
   TokenKind["LBRACKET"] = "TOKEN_LBRACKET";
   TokenKind["LE"] = "TOKEN_LE";
   TokenKind["LG"] = "TOKEN_LG";
@@ -1262,6 +1270,7 @@ const indexPattern = /-?\d+/y;
 const intPattern = /-?[0-9]+/y;
 const namePattern = /[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*/y;
 const whitespace = new Set([" ", "\n", "\t", "\r"]);
+const nameFirstPattern = /[\u0080-\uFFFFa-zA-Z_]/; // don't set sticky bit
 
 /**
  * JSONPath lexical scanner.
@@ -1334,6 +1343,11 @@ class Lexer {
     if (ch) this.backup();
     return ch;
   }
+  peekMatch(pattern) {
+    const ch = this.next();
+    if (ch) this.backup();
+    return pattern.test(ch);
+  }
   accept(valid) {
     const ch = this.next();
     if (valid.has(ch)) return true;
@@ -1463,10 +1477,28 @@ function lexDescendantSelection(l) {
     l.emit(TokenKind.NAME);
     return lexSegment;
   }
-  if (!l.environment.strict && l.acceptMatchRun(l.environment.keysPattern)) {
-    // Non-standard keys selector
-    l.emit(TokenKind.KEYS);
-    return lexSegment;
+  if (!l.environment.strict) {
+    // We're effectively disabling the _key selector_ and _keys filter selector_ if a
+    // custom _keys selector_ is set.
+    if (l.environment.keysPattern.source === "~" && l.peek() === "~") {
+      l.next();
+      if (l.peekMatch(nameFirstPattern)) {
+        // Non-standard key selector
+        l.ignore(); // ignore ~
+        l.acceptMatchRun(namePattern);
+        l.emit(TokenKind.KEY);
+        return lexSegment;
+      } else {
+        // Non-standard keys selector
+        l.emit(TokenKind.KEYS);
+        return lexSegment;
+      }
+    } else if (l.acceptMatchRun(l.environment.keysPattern)) {
+      // NOTE: A custom keys pattern does not play well with other non-standard key selectors.
+      // We leave this here for backwards compatibility.
+      l.emit(TokenKind.KEYS);
+      return lexSegment;
+    }
   }
   const ch = l.next();
   switch (ch) {
@@ -1491,9 +1523,28 @@ function lexDotSelector(l) {
     l.error("unexpected whitespace after dot");
     return null;
   }
-  if (!l.environment.strict && l.acceptMatchRun(l.environment.keysPattern)) {
-    l.emit(TokenKind.KEYS);
-    return lexSegment;
+  if (!l.environment.strict) {
+    // We're effectively disabling the _key selector_ and _keys filter selector_ if a
+    // custom _keys selector_ is set.
+    if (l.environment.keysPattern.source === "~" && l.peek() === "~") {
+      l.next();
+      if (l.peekMatch(nameFirstPattern)) {
+        // Non-standard key selector
+        l.ignore(); // ignore ~
+        l.acceptMatchRun(namePattern);
+        l.emit(TokenKind.KEY);
+        return lexSegment;
+      } else {
+        // Non-standard keys selector
+        l.emit(TokenKind.KEYS);
+        return lexSegment;
+      }
+    } else if (l.acceptMatchRun(l.environment.keysPattern)) {
+      // NOTE: A custom keys pattern does not play well with other non-standard key selectors.
+      // We leave this here for backwards compatibility.
+      l.emit(TokenKind.KEYS);
+      return lexSegment;
+    }
   }
   if (l.acceptMatchRun(namePattern)) {
     l.emit(TokenKind.NAME);
@@ -1516,8 +1567,25 @@ function lexInsideBracketedSelection(l) {
       continue;
     }
     if (!l.environment.strict && l.acceptMatchRun(l.environment.keysPattern)) {
-      l.emit(TokenKind.KEYS);
-      continue;
+      switch (l.peek()) {
+        case "'":
+          l.ignore(); // ~
+          l.next();
+          return lexSingleQuoteKeyString(l);
+        case '"':
+          l.ignore(); // ~
+          l.next();
+          return lexDoubleQuoteKeyString(l);
+        case "?":
+          l.ignore(); // ~
+          l.next();
+          l.emit(TokenKind.KEYS_FILTER);
+          l.filterLevel += 1;
+          return lexInsideFilter;
+        default:
+          l.emit(TokenKind.KEYS);
+          continue;
+      }
     }
     const ch = l.next();
     switch (ch) {
@@ -1604,7 +1672,7 @@ function lexInsideFilter(l) {
         l.emit(TokenKind.CURRENT);
         return lexSegment;
       case "#":
-        l.emit(TokenKind.KEY);
+        l.emit(TokenKind.CURRENT_KEY);
         return lexSegment;
       case ".":
         l.backup();
@@ -1704,8 +1772,7 @@ function lexInsideFilter(l) {
  * @param state - The state function to return control to.
  * @returns String tokenizing state function.
  */
-function makeLexString(quote, state) {
-  // eslint-disable-next-line sonarjs/cognitive-complexity
+function makeLexString(quote, state, token_kind) {
   function _lexString(l) {
     l.ignore();
     if (l.peek() === quote) {
@@ -1731,7 +1798,7 @@ function makeLexString(quote, state) {
       }
       if (ch === quote) {
         l.backup();
-        l.emit(quote === "'" ? TokenKind.SINGLE_QUOTE_STRING : TokenKind.DOUBLE_QUOTE_STRING);
+        l.emit(token_kind);
         l.next();
         l.ignore();
         return state;
@@ -1740,10 +1807,12 @@ function makeLexString(quote, state) {
   }
   return _lexString;
 }
-const lexSingleQuoteStringInsideBracketSelection = makeLexString("'", lexInsideBracketedSelection);
-const lexDoubleQuoteStringInsideBracketSelection = makeLexString('"', lexInsideBracketedSelection);
-const lexSingleQuoteStringInsideFilterExpression = makeLexString("'", lexInsideFilter);
-const lexDoubleQuoteStringInsideFilterExpression = makeLexString('"', lexInsideFilter);
+const lexSingleQuoteStringInsideBracketSelection = makeLexString("'", lexInsideBracketedSelection, TokenKind.SINGLE_QUOTE_STRING);
+const lexDoubleQuoteStringInsideBracketSelection = makeLexString('"', lexInsideBracketedSelection, TokenKind.DOUBLE_QUOTE_STRING);
+const lexSingleQuoteStringInsideFilterExpression = makeLexString("'", lexInsideFilter, TokenKind.SINGLE_QUOTE_STRING);
+const lexDoubleQuoteStringInsideFilterExpression = makeLexString('"', lexInsideFilter, TokenKind.DOUBLE_QUOTE_STRING);
+const lexSingleQuoteKeyString = makeLexString("'", lexInsideBracketedSelection, TokenKind.KEY_SINGLE_QUOTE_STRING);
+const lexDoubleQuoteKeyString = makeLexString('"', lexInsideBracketedSelection, TokenKind.KEY_DOUBLE_QUOTE_STRING);
 
 /**
  * Base class for all JSONPath segments and selectors.
@@ -1784,7 +1853,7 @@ class NameSelector extends JSONPathSelector {
   resolve(nodes) {
     const rv = [];
     for (const node of nodes) {
-      if (hasStringKey(node.value, this.name)) {
+      if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
         rv.push(new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root));
       }
     }
@@ -1792,7 +1861,7 @@ class NameSelector extends JSONPathSelector {
   }
   *lazyResolve(nodes) {
     for (const node of nodes) {
-      if (hasStringKey(node.value, this.name)) {
+      if (!isArray(node.value) && hasStringKey(node.value, this.name)) {
         yield new JSONPathNode(node.value[this.name], node.location.concat(this.name), node.root);
       }
     }
@@ -1868,7 +1937,7 @@ class SliceSelector extends JSONPathSelector {
   *lazyResolve(nodes) {
     for (const node of nodes) {
       if (!isArray(node.value)) continue;
-      for (const [i, value] of this.slice(node.value, this.start, this.stop, this.step)) {
+      for (const [i, value] of this.lazySlice(node.value, this.start, this.stop, this.step)) {
         yield new JSONPathNode(value, node.location.concat(i), node.root);
       }
     }
@@ -1931,6 +2000,45 @@ class SliceSelector extends JSONPathSelector {
     }
     return slicedArray;
   }
+
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  *lazySlice(arr, start, stop, step) {
+    if (!arr.length) return;
+
+    // Handle negative and undefined start values
+    if (start === undefined || start === null) {
+      start = step && step < 0 ? arr.length - 1 : 0;
+    } else if (start < 0) {
+      start = Math.max(arr.length + start, 0);
+    } else {
+      start = Math.min(start, arr.length - 1);
+    }
+
+    // Handle negative and undefined stop values
+    if (stop === undefined || stop === null) {
+      stop = step && step < 0 ? -1 : arr.length;
+    } else if (stop < 0) {
+      stop = Math.max(arr.length + stop, -1);
+    } else {
+      stop = Math.min(stop, arr.length);
+    }
+
+    // Perform the slice
+    if (step === undefined) {
+      // Default to a step of 1
+      for (let i = start; i < stop; i += 1) {
+        yield [i, arr[i]];
+      }
+    } else if (step > 0) {
+      for (let i = start; i < stop; i += step) {
+        yield [i, arr[i]];
+      }
+    } else if (step < 0) {
+      for (let i = start; i > stop; i += step) {
+        yield [i, arr[i]];
+      }
+    }
+  }
 }
 class WildcardSelector extends JSONPathSelector {
   constructor(environment, token) {
@@ -1997,8 +2105,6 @@ class RecursiveDescentSegment extends JSONPathSelector {
         }
       }
     }
-
-    // console.log(JSON.stringify(rv.map((n: any) => n.value)));
     return this.selector.resolve(rv);
   }
   *lazyResolve(nodes) {
@@ -2355,6 +2461,38 @@ class CurrentKey extends FilterExpression {
   }
 }
 
+class KeySelector extends JSONPathSelector {
+  constructor(environment, token, key) {
+    let shorthand = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    super(environment, token);
+    this.environment = environment;
+    this.token = token;
+    this.key = key;
+    this.shorthand = shorthand;
+  }
+  resolve(nodes) {
+    const rv = [];
+    for (const node of nodes) {
+      if (node.value instanceof String || isArray(node.value)) continue;
+      if (isObject(node.value) && hasStringKey(node.value, this.key)) {
+        rv.push(new JSONPathNode(this.key, node.location.concat(`${KEY_MARK}${this.key}`), node.root));
+      }
+    }
+    return rv;
+  }
+  *lazyResolve(nodes) {
+    for (const node of nodes) {
+      if (node.value instanceof String || isArray(node.value)) continue;
+      if (isObject(node.value) && hasStringKey(node.value, this.key)) {
+        yield new JSONPathNode(this.key, node.location.concat(`${KEY_MARK}${this.key}`), node.root);
+      }
+    }
+  }
+  toString() {
+    return this.shorthand ? `[~'${this.key.replaceAll("'", "\\'")}']` : `~'${this.key.replaceAll("'", "\\'")}'`;
+  }
+}
+
 /**
  * Object property name selector or array index selector.
  */
@@ -2371,10 +2509,8 @@ class KeysSelector extends JSONPathSelector {
     for (const node of nodes) {
       if (node.value instanceof String || isArray(node.value)) continue;
       if (isObject(node.value)) {
-        let i = 0;
         for (const [key, _] of this.environment.entries(node.value)) {
-          rv.push(new JSONPathNode(key, node.location.concat("[~]", `[${i}]`), node.root));
-          i++;
+          rv.push(new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root));
         }
       }
     }
@@ -2384,10 +2520,8 @@ class KeysSelector extends JSONPathSelector {
     for (const node of nodes) {
       if (node.value instanceof String || isArray(node.value)) continue;
       if (isObject(node.value)) {
-        let i = 0;
         for (const [key, _] of this.environment.entries(node.value)) {
-          yield new JSONPathNode(key, node.location.concat("[~]", `[${i}]`), node.root);
-          i++;
+          yield new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root);
         }
       }
     }
@@ -2396,6 +2530,56 @@ class KeysSelector extends JSONPathSelector {
     return this.shorthand ? "[~]" : "~";
   }
 }
+class KeysFilterSelector extends JSONPathSelector {
+  constructor(environment, token, expression) {
+    super(environment, token);
+    this.environment = environment;
+    this.token = token;
+    this.expression = expression;
+  }
+  resolve(nodes) {
+    const rv = [];
+    for (const node of nodes) {
+      if (node.value instanceof String || isArray(node.value)) continue;
+      if (isObject(node.value)) {
+        for (const [key, value] of this.environment.entries(node.value)) {
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            currentKey: key
+          };
+          if (this.expression.evaluate(filterContext)) {
+            rv.push(new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root));
+          }
+        }
+      }
+    }
+    return rv;
+  }
+  *lazyResolve(nodes) {
+    for (const node of nodes) {
+      if (node.value instanceof String || isArray(node.value)) continue;
+      if (isObject(node.value)) {
+        for (const [key, value] of this.environment.entries(node.value)) {
+          const filterContext = {
+            environment: this.environment,
+            currentValue: value,
+            rootValue: node.root,
+            lazy: true,
+            currentKey: key
+          };
+          if (this.expression.evaluate(filterContext)) {
+            yield new JSONPathNode(key, node.location.concat(`${KEY_MARK}${key}`), node.root);
+          }
+        }
+      }
+    }
+  }
+  toString() {
+    return `~?${this.expression.toString()}`;
+  }
+}
 
 const PRECEDENCE_LOWEST = 1;
 const PRECEDENCE_LOGICAL_OR = 4;
@@ -2412,7 +2596,7 @@ const COMPARISON_OPERATORS = new Set(["==", ">=", ">", "<=", "<", "!="]);
 class Parser {
   constructor(environment) {
     this.environment = environment;
-    this.tokenMap = new Map([[TokenKind.FALSE, this.parseBoolean], [TokenKind.NUMBER, this.parseNumber], [TokenKind.LPAREN, this.parseGroupedExpression], [TokenKind.NOT, this.parsePrefixExpression], [TokenKind.NULL, this.parseNull], [TokenKind.ROOT, this.parseRootQuery], [TokenKind.CURRENT, this.parseRelativeQuery], [TokenKind.SINGLE_QUOTE_STRING, this.parseString], [TokenKind.DOUBLE_QUOTE_STRING, this.parseString], [TokenKind.TRUE, this.parseBoolean], [TokenKind.FUNCTION, this.parseFunction], [TokenKind.KEY, this.parseCurrentKey], [TokenKind.KEY, this.parseCurrentKey]]);
+    this.tokenMap = new Map([[TokenKind.FALSE, this.parseBoolean], [TokenKind.NUMBER, this.parseNumber], [TokenKind.LPAREN, this.parseGroupedExpression], [TokenKind.NOT, this.parsePrefixExpression], [TokenKind.NULL, this.parseNull], [TokenKind.ROOT, this.parseRootQuery], [TokenKind.CURRENT, this.parseRelativeQuery], [TokenKind.SINGLE_QUOTE_STRING, this.parseString], [TokenKind.DOUBLE_QUOTE_STRING, this.parseString], [TokenKind.TRUE, this.parseBoolean], [TokenKind.FUNCTION, this.parseFunction], [TokenKind.CURRENT_KEY, this.parseCurrentKey]]);
   }
   parse(stream) {
     if (stream.current.kind === TokenKind.ROOT) stream.next();
@@ -2444,6 +2628,8 @@ class Parser {
         return new NameSelector(this.environment, stream.current, stream.current.value, true);
       case TokenKind.WILD:
         return new WildcardSelector(this.environment, stream.current, true);
+      case TokenKind.KEY:
+        return new KeySelector(this.environment, stream.current, stream.current.value, true);
       case TokenKind.KEYS:
         return new KeysSelector(this.environment, stream.current, true);
       case TokenKind.DDOT:
@@ -2539,6 +2725,13 @@ class Parser {
         case TokenKind.WILD:
           items.push(new WildcardSelector(this.environment, stream.current));
           break;
+        case TokenKind.KEY_SINGLE_QUOTE_STRING:
+        case TokenKind.KEY_DOUBLE_QUOTE_STRING:
+          items.push(new KeySelector(this.environment, stream.current, this.decodeString(stream.current, true), false));
+          break;
+        case TokenKind.KEYS_FILTER:
+          items.push(this.parseFilter(stream, true));
+          break;
         case TokenKind.KEYS:
           items.push(new KeysSelector(this.environment, stream.current));
           break;
@@ -2559,6 +2752,7 @@ class Parser {
     return new BracketedSelection(this.environment, token, items);
   }
   parseFilter(stream) {
+    let keys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     const tok = stream.next();
     const expr = this.parseFilterExpression(stream);
     if (expr instanceof FunctionExtension) {
@@ -2567,7 +2761,7 @@ class Parser {
         throw new JSONPathTypeError(`result of ${expr.name}()  must be compared`, expr.token);
       }
     }
-    return new FilterSelector(this.environment, tok, new LogicalExpression(tok, expr));
+    return keys ? new KeysFilterSelector(this.environment, tok, new LogicalExpression(tok, expr)) : new FilterSelector(this.environment, tok, new LogicalExpression(tok, expr));
   }
   parseBoolean(stream) {
     if (stream.current.kind === TokenKind.FALSE) return new BooleanLiteral(stream.current, false);
@@ -2602,13 +2796,20 @@ class Parser {
     return new InfixExpression(tok, left, operator, right);
   }
   parseGroupedExpression(stream) {
-    stream.next();
+    if (stream.peek.kind === TokenKind.RPAREN) {
+      throw new JSONPathSyntaxError(`empty paren expression`, stream.current);
+    }
+    stream.next(); // eat open paren
+
     let expr = this.parseFilterExpression(stream);
     stream.next();
     while (stream.current.kind !== TokenKind.RPAREN) {
       if (stream.current.kind === TokenKind.EOF) {
         throw new JSONPathSyntaxError("unbalanced parentheses", stream.current);
       }
+      if (!BINARY_OPERATORS.has(stream.current.kind)) {
+        throw new JSONPathSyntaxError(`expected an expression, found '${stream.current.value}'`, stream.current);
+      }
       expr = this.parseInfixExpression(stream, expr);
     }
     stream.expect(TokenKind.RPAREN);
@@ -2664,7 +2865,7 @@ class Parser {
           msg = "end of expression";
           break;
         default:
-          msg = `'${stream.current.value}`;
+          msg = `'${stream.current.value}'`;
       }
       throw new JSONPathSyntaxError(`unexpected ${msg}`, stream.current);
     }
@@ -2988,6 +3189,7 @@ var index$1 = /*#__PURE__*/Object.freeze({
   JSONPathRecursionLimitError: JSONPathRecursionLimitError,
   JSONPathSyntaxError: JSONPathSyntaxError,
   JSONPathTypeError: JSONPathTypeError,
+  KEY_MARK: KEY_MARK,
   Nothing: Nothing,
   Token: Token,
   TokenKind: TokenKind,
@@ -3480,6 +3682,6 @@ var index = /*#__PURE__*/Object.freeze({
   apply: apply
 });
 
-const version = "1.2.0";
+const version = "1.3.0";
 
 export { DEFAULT_ENVIRONMENT, FunctionExpressionType, JSONPatch, JSONPatchError, JSONPatchTestFailure, JSONPath, JSONPathEnvironment, JSONPathError, JSONPathIndexError, JSONPathLexerError, JSONPathNode, JSONPathNodeList, JSONPathRecursionLimitError, JSONPathSyntaxError, JSONPathTypeError, JSONPointer, Nothing, RelativeJSONPointer, Token, TokenKind, UNDEFINED, apply, compile, index as jsonpatch, index$1 as jsonpath, index$3 as jsonpointer, lazyQuery, query, resolve, version };