@routier/core 0.7.0 → 0.8.0

package/dist/expressions/index.js

@@ -720,6 +720,7 @@ const readsAProperty = (expression)=>{
 91(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.d(__webpack_exports__, {
   MY: () => (toExpression),
+  Pl: () => (parseSelector),
   oH: () => (parseFragment),
   pg: () => (combineExpressions)
 });
@@ -728,6 +729,7 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var _schema__rspack_import_2 = __webpack_require__(537);
 /* import */ var _evaluate__rspack_import_3 = __webpack_require__(379);
 /* import */ var _fold__rspack_import_4 = __webpack_require__(43);
+/* import */ var _utils__rspack_import_6 = __webpack_require__(63);
 /* import */ var _types__rspack_import_1 = __webpack_require__(27);
 
 
@@ -735,6 +737,7 @@ __webpack_require__.d(__webpack_exports__, {
 
 
 
+
 // Error message constants
 const ERROR_MESSAGES = {
     PROPERTY_NOT_FOUND: (path)=>`Error parsing query, could not find PropertyInfo for path: ${path}`,
@@ -1342,6 +1345,9 @@ const COALESCE_OPERATORS = sourceKeyed({
         // A comparison always names a schema property, so the condition alone settles it
         return true;
     }
+    if (operand.kind === "opaque") {
+        return operand.reads.some(containsProperty);
+    }
     return operand.kind === "arithmetic" && (containsProperty(operand.left) || containsProperty(operand.right) || operand.extra != null && containsProperty(operand.extra));
 };
 const DECLARATION_KEYWORDS = new Set([
@@ -1519,13 +1525,18 @@ const resolveParamPath = (paramsName, path, data)=>{
     scope;
     paramsName;
     params;
+    /**
+     * Whether this parses a value selector rather than a filter, and so reads a call it has no node for
+     * as an `OpaqueOperand` instead of refusing it.
+     */ readsValues;
     /** Set when a param value shaped the tree itself (e.g. x[p.name]) — such templates cannot be cached. */ structurallyDependsOnParams = false;
-    constructor(schema, stream, scope, paramsName, params){
+    constructor(schema, stream, scope, paramsName, params, readsValues = false){
         this.schema = schema;
         this.stream = stream;
         this.scope = scope;
         this.paramsName = paramsName;
         this.params = params;
+        this.readsValues = readsValues;
     }
     parse() {
         const expression = this.parseOr();
@@ -1547,6 +1558,71 @@ const resolveParamPath = (paramsName, path, data)=>{
         }
         return answer;
     }
+    /**
+     * What a value selector returns: one value, or the fields of an object literal.
+     *
+     * A block body is read only when it does nothing but return, which is what a transpiler makes of an
+     * arrow function. Anything more is refused, and the caller falls back to running the function.
+     */ parseSelector() {
+        const block = this.stream.matchPunctuation("{");
+        if (block) {
+            const keyword = this.stream.next();
+            if (keyword.kind !== "identifier" || keyword.value !== "return") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED("a selector block that does more than return"));
+            }
+        }
+        const selected = this.stream.isPunctuation("{") ? this.parseObjectLiteral() : this.stream.isPunctuation("(") && this.stream.isPunctuation("{", 1) ? this.parseBracketedObjectLiteral() : this.parseInterpolation();
+        if (block) {
+            this.stream.matchPunctuation(";");
+            this.stream.expectPunctuation("}");
+        }
+        if (!this.stream.isAtEnd) {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED(`unexpected token '${this.stream.peek()?.value}'`));
+        }
+        return selected;
+    }
+    /** `({ … })`, the arrow body that returns an object. */ parseBracketedObjectLiteral() {
+        this.stream.expectPunctuation("(");
+        const fields = this.parseObjectLiteral();
+        this.stream.expectPunctuation(")");
+        return fields;
+    }
+    /**
+     * The fields of an object literal, each one value.
+     *
+     * A field's value is read without a top-level conditional, which needs brackets here: the look-ahead
+     * for a `?` does not stop at the comma that ends the field.
+     */ parseObjectLiteral() {
+        this.stream.expectPunctuation("{");
+        const fields = [];
+        while(!this.stream.matchPunctuation("}")){
+            const key = this.stream.next();
+            if (key.kind !== "identifier" && key.kind !== "string") {
+                throw new Error(ERROR_MESSAGES.UNSUPPORTED(`the object key '${key.value}'`));
+            }
+            fields.push({
+                name: key.value,
+                operand: this.stream.matchPunctuation(":") ? this.parseValue() : this.parseShorthand(key)
+            });
+            if (!this.stream.matchPunctuation(",")) {
+                this.stream.expectPunctuation("}");
+                break;
+            }
+        }
+        return fields;
+    }
+    /** `{ name }`, which reads what the parameter list bound `name` to. */ parseShorthand(key) {
+        const binding = key.kind === "identifier" ? this.scope.get(key.value) : undefined;
+        if (binding == null || binding.kind === "inlined") {
+            throw new Error(ERROR_MESSAGES.VARIABLE_VALUE(key.value));
+        }
+        return this.parseChain({
+            kind: binding.kind,
+            path: [
+                ...binding.path
+            ]
+        });
+    }
     /** The expression a `{ … }` block answers with. */ parseBlock() {
         this.stream.expectPunctuation("{");
         const answer = this.parseStatements();
@@ -1810,7 +1886,7 @@ const resolveParamPath = (paramsName, path, data)=>{
      * A structural dependence found inside propagates outward: the template it belongs to cannot be
      * cached either.
      */ parseNested(source) {
-        const nested = new ExpressionParser(this.schema, new TokenStream(tokenize(source)), this.scope, this.paramsName, this.params);
+        const nested = new ExpressionParser(this.schema, new TokenStream(tokenize(source)), this.scope, this.paramsName, this.params, this.readsValues);
         const operand = nested.parseInterpolation();
         // Leftover tokens mean the interpolation held something this reads only part of. Silently
         // keeping the part it understood is the worst outcome available: `${x.age > 5 ? "a" : "b"}`
@@ -2102,7 +2178,7 @@ const resolveParamPath = (paramsName, path, data)=>{
             if (argument.kind === "method-call") {
                 throw new Error(ERROR_MESSAGES.UNSUPPORTED("nested method call inside .includes()"));
             }
-            if (argument.kind === "arithmetic" || argument.kind === "conditional") {
+            if (argument.kind === "arithmetic" || argument.kind === "conditional" || argument.kind === "opaque") {
                 throw new Error(ERROR_MESSAGES.UNSUPPORTED("arithmetic inside .includes()"));
             }
             return {
@@ -2196,7 +2272,7 @@ const resolveParamPath = (paramsName, path, data)=>{
                         if (argument.kind === "method-call") {
                             throw new Error(ERROR_MESSAGES.UNSUPPORTED(`nested method call inside .${method}()`));
                         }
-                        if (argument.kind === "arithmetic" || argument.kind === "conditional") {
+                        if (argument.kind === "arithmetic" || argument.kind === "conditional" || argument.kind === "opaque") {
                             throw new Error(ERROR_MESSAGES.UNSUPPORTED(`arithmetic inside .${method}()`));
                         }
                         return {
@@ -2206,9 +2282,20 @@ const resolveParamPath = (paramsName, path, data)=>{
                             argument
                         };
                     }
+                    if (this.readsValues) {
+                        return this.withGroupCall(this.opaqueCall(this.resolveChain(options.kind, path, transformer, locale)));
+                    }
                     throw new Error(ERROR_MESSAGES.UNSUPPORTED(`method '.${method}()'`));
                 }
                 if (transformer != null) {
+                    if (this.readsValues) {
+                        return this.withGroupCall({
+                            kind: "opaque",
+                            reads: [
+                                this.resolveChain(options.kind, path, transformer, locale)
+                            ]
+                        });
+                    }
                     throw new Error(ERROR_MESSAGES.UNSUPPORTED("property access after a transform method"));
                 }
                 path.push(segment.value);
@@ -2353,10 +2440,39 @@ const resolveParamPath = (paramsName, path, data)=>{
                     argument
                 };
             }
+            // Any other member or call of a value, which a selector reads through
+            if (this.readsValues) {
+                this.stream.next();
+                this.stream.next();
+                receiver = this.stream.isPunctuation("(") ? this.opaqueCall(receiver) : {
+                    kind: "opaque",
+                    reads: [
+                        receiver
+                    ]
+                };
+                continue;
+            }
             break;
         }
         return receiver;
     }
+    /** A call with no node of its own, from its `(`, kept for what its receiver and arguments read. */ opaqueCall(receiver) {
+        const reads = [
+            receiver
+        ];
+        this.stream.expectPunctuation("(");
+        while(!this.stream.matchPunctuation(")")){
+            reads.push(this.parseValue());
+            if (!this.stream.matchPunctuation(",")) {
+                this.stream.expectPunctuation(")");
+                break;
+            }
+        }
+        return {
+            kind: "opaque",
+            reads
+        };
+    }
     withValueTransformer(operand) {
         if (this.stream.isPunctuation(".")) {
             const method = this.stream.peek(1);
@@ -2390,6 +2506,10 @@ const resolveParamPath = (paramsName, path, data)=>{
         if (right.kind === "method-call") {
             throw new Error(ERROR_MESSAGES.UNSUPPORTED("method call on the right side of a comparison"));
         }
+        // A comparison is a tree a backend renders, and this operand has no node in one
+        if (left.kind === "opaque" || right.kind === "opaque") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("a call with no expression form inside a comparison"));
+        }
         if (needsBrackets(left) || needsBrackets(right)) {
             throw new Error(ERROR_MESSAGES.UNSUPPORTED("a bitwise or nullish operator compared without brackets, which JavaScript reads the other way round"));
         }
@@ -2603,6 +2723,9 @@ const resolveParamPath = (paramsName, path, data)=>{
         if (operand.kind === "method-call") {
             throw new Error(ERROR_MESSAGES.UNSUPPORTED("a method call inside arithmetic"));
         }
+        if (operand.kind === "opaque") {
+            throw new Error(ERROR_MESSAGES.UNSUPPORTED("a call with no expression form inside arithmetic"));
+        }
         return this.createValueExpression(operand, null, /* applyConverter */ false);
     }
     createPropertyExpression(operand) {
@@ -2938,6 +3061,104 @@ const toExpression = (schema, fn, params)=>{
         return _types__rspack_import_1/* .Expression.notParsable */.r4.notParsable(refusalOf(error));
     }
 };
+const collectReads = (operand, into)=>{
+    switch(operand.kind){
+        case "property":
+            into.add(operand.property);
+            return;
+        case "method-call":
+            collectReads(operand.target, into);
+            collectReads(operand.argument, into);
+            return;
+        case "arithmetic":
+            collectReads(operand.left, into);
+            collectReads(operand.right, into);
+            if (operand.extra != null) {
+                collectReads(operand.extra, into);
+            }
+            return;
+        case "conditional":
+            for (const property of (0,_utils__rspack_import_6/* .getProperties */.oY)(operand.condition)){
+                into.add(property);
+            }
+            collectReads(operand.whenTrue, into);
+            collectReads(operand.whenFalse, into);
+            return;
+        case "opaque":
+            for (const read of operand.reads){
+                collectReads(read, into);
+            }
+            return;
+    }
+};
+const selectedValue = (operand)=>{
+    const found = new Set();
+    collectReads(operand, found);
+    const reads = [
+        ...found
+    ];
+    return {
+        property: reads.length === 1 ? reads[0] : null,
+        reads,
+        isDirectProperty: operand.kind === "property" && operand.transformer == null
+    };
+};
+// Keyed like the template cache. A selector takes no params, so every result is cacheable
+const selectorCache = new WeakMap();
+/**
+ * Reads a sort, map, group or `nearest` selector with the grammar filters use, for what its value is
+ * read from.
+ *
+ * Not for evaluating it: the caller's function stays the value, and nothing here renders one. A plugin
+ * decides from the result whether it can run the option. One that orders or projects by column cannot
+ * run a value that is not the property itself, and one that runs the function over stored rows cannot
+ * run it over a renamed property.
+ *
+ * So the grammar is wider here than for a filter. A call it has no node for, such as `getFullYear()`,
+ * is kept for the operands it reads rather than refused, since the function it came from still runs.
+ *
+ * `not-parsable` is not logged. The option runs as it did before the selector was parsed.
+ *
+ * Cached by function source per schema, like `toExpression`. The result is shared, so it is read-only.
+ */ const parseSelector = (schema, selector)=>{
+    const source = selector.toString();
+    let bySource = selectorCache.get(schema);
+    const cached = bySource?.get(source);
+    if (cached != null) {
+        return cached;
+    }
+    let parsed;
+    try {
+        const shape = resolveFunctionShape(source, false);
+        const parser = new ExpressionParser(schema, new TokenStream(tokenize(shape.body)), shape.scope, null, undefined, true);
+        const selected = parser.parseSelector();
+        parsed = Array.isArray(selected) ? {
+            kind: "object",
+            fields: selected.map((field)=>({
+                    name: field.name,
+                    ...selectedValue(field.operand)
+                }))
+        } : {
+            kind: "value",
+            value: selectedValue(selected)
+        };
+    } catch (error) {
+        parsed = {
+            kind: "not-parsable",
+            reason: refusalOf(error)
+        };
+    }
+    if (bySource == null) {
+        bySource = new Map();
+        selectorCache.set(schema, bySource);
+    }
+    // Stryker disable next-line all: the same resource bound as the template cache's
+    if (bySource.size >= MAX_CACHED_TEMPLATES_PER_SCHEMA) {
+        bySource.clear();
+    }
+    bySource.set(source, parsed);
+    return parsed;
+}; // #endregion
 
 
 },
@@ -3552,6 +3773,7 @@ __webpack_require__.d(__webpack_exports__, {
   LU: () => (/* reexport safe */ _utils__rspack_import_5.LU),
   MY: () => (/* reexport safe */ _parser__rspack_import_3.MY),
   Nb: () => (/* reexport safe */ _callSource__rspack_import_0.N),
+  Pl: () => (/* reexport safe */ _parser__rspack_import_3.Pl),
   SC: () => (/* reexport safe */ _types__rspack_import_4.SC),
   Sm: () => (/* reexport safe */ _types__rspack_import_4.Sm),
   Sv: () => (/* reexport safe */ _fold__rspack_import_2.Sv),
@@ -3610,11 +3832,12 @@ var __webpack_exports__forEach = __webpack_exports__.jJ;
 var __webpack_exports__getProperties = __webpack_exports__.oY;
 var __webpack_exports__operandValue = __webpack_exports__.Vv;
 var __webpack_exports__parseFragment = __webpack_exports__.oH;
+var __webpack_exports__parseSelector = __webpack_exports__.Pl;
 var __webpack_exports__peelCalls = __webpack_exports__.CC;
 var __webpack_exports__renderCallAsJs = __webpack_exports__.ax;
 var __webpack_exports__toExpression = __webpack_exports__.MY;
 var __webpack_exports__toPredicate = __webpack_exports__.Vu;
 var __webpack_exports__toStrictPredicate = __webpack_exports__.wS;
-export { __webpack_exports__CALL_SOURCE as CALL_SOURCE, __webpack_exports__CallExpression as CallExpression, __webpack_exports__ComparatorExpression as ComparatorExpression, __webpack_exports__EXPRESSION_TYPES as EXPRESSION_TYPES, __webpack_exports__EmptyExpression as EmptyExpression, __webpack_exports__Expression as Expression, __webpack_exports__FOLDABLE as FOLDABLE, __webpack_exports__NotParsableExpression as NotParsableExpression, __webpack_exports__OperatorExpression as OperatorExpression, __webpack_exports__PropertyExpression as PropertyExpression, __webpack_exports__UNRESOLVED as UNRESOLVED, __webpack_exports__ValueExpression as ValueExpression, __webpack_exports__childrenOf as childrenOf, __webpack_exports__combineExpressions as combineExpressions, __webpack_exports__evaluate as evaluate, __webpack_exports__foldConstantCalls as foldConstantCalls, __webpack_exports__foldedOperandValue as foldedOperandValue, __webpack_exports__forEach as forEach, __webpack_exports__getProperties as getProperties, __webpack_exports__operandValue as operandValue, __webpack_exports__parseFragment as parseFragment, __webpack_exports__peelCalls as peelCalls, __webpack_exports__renderCallAsJs as renderCallAsJs, __webpack_exports__toExpression as toExpression, __webpack_exports__toPredicate as toPredicate, __webpack_exports__toStrictPredicate as toStrictPredicate };
+export { __webpack_exports__CALL_SOURCE as CALL_SOURCE, __webpack_exports__CallExpression as CallExpression, __webpack_exports__ComparatorExpression as ComparatorExpression, __webpack_exports__EXPRESSION_TYPES as EXPRESSION_TYPES, __webpack_exports__EmptyExpression as EmptyExpression, __webpack_exports__Expression as Expression, __webpack_exports__FOLDABLE as FOLDABLE, __webpack_exports__NotParsableExpression as NotParsableExpression, __webpack_exports__OperatorExpression as OperatorExpression, __webpack_exports__PropertyExpression as PropertyExpression, __webpack_exports__UNRESOLVED as UNRESOLVED, __webpack_exports__ValueExpression as ValueExpression, __webpack_exports__childrenOf as childrenOf, __webpack_exports__combineExpressions as combineExpressions, __webpack_exports__evaluate as evaluate, __webpack_exports__foldConstantCalls as foldConstantCalls, __webpack_exports__foldedOperandValue as foldedOperandValue, __webpack_exports__forEach as forEach, __webpack_exports__getProperties as getProperties, __webpack_exports__operandValue as operandValue, __webpack_exports__parseFragment as parseFragment, __webpack_exports__parseSelector as parseSelector, __webpack_exports__peelCalls as peelCalls, __webpack_exports__renderCallAsJs as renderCallAsJs, __webpack_exports__toExpression as toExpression, __webpack_exports__toPredicate as toPredicate, __webpack_exports__toStrictPredicate as toStrictPredicate };
 
 //# sourceMappingURL=index.js.map