@routier/core 0.7.0 → 0.8.0

package/dist/expressions/parser.d.ts

@@ -1,4 +1,4 @@
-import { CompiledSchema } from "../schema";
+import { CompiledSchema, PropertyInfo } from "../schema";
 import { Expression, Filter, ParamsFilter } from "./types";
 export declare const combineExpressions: (...expressions: Expression[]) => Expression;
 /**
@@ -21,3 +21,44 @@ export declare const combineExpressions: (...expressions: Expression[]) => Expre
  */
 export declare const parseFragment: (schema: CompiledSchema<any>, body: string, rootName: string) => Expression;
 export declare const toExpression: <T extends any, P extends any>(schema: CompiledSchema<any>, fn: Filter<T> | ParamsFilter<T, P>, params?: P) => Expression;
+/** What one value a sort, map, group or `nearest` selector returns is read from. */
+export type SelectedValue = {
+    /** The schema property the value is read from, when it reads exactly one. */
+    property: PropertyInfo<any> | null;
+    /** Every schema property the value is read from, at any depth of the schema. */
+    reads: PropertyInfo<any>[];
+    /**
+     * Whether the value is `property` itself. `false` for anything computed from it: a call, arithmetic,
+     * `.length`, or a member of a value that is not a property.
+     */
+    isDirectProperty: boolean;
+};
+export type ParsedSelector = {
+    kind: "value";
+    value: SelectedValue;
+} | {
+    kind: "object";
+    fields: (SelectedValue & {
+        name: string;
+    })[];
+} | {
+    kind: "not-parsable";
+    reason: string;
+};
+/**
+ * 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.
+ */
+export declare const parseSelector: (schema: CompiledSchema<any>, selector: (...args: any[]) => unknown) => ParsedSelector;