@routier/core 0.6.0 → 0.7.0

package/dist/expressions/types.d.ts

@@ -5,48 +5,49 @@ import { CompiledSchemaCore, PropertyInfo } from "../schema";
  *
  * See `Expression.toJson`.
  */
-export type SerializedValue = {
-    k: "raw";
-    v: string | number | boolean | null;
+export type SerializedValue = string | number | boolean | null | SerializedValue[] | {
+    date: string;
 } | {
-    k: "date";
-    v: string;
+    undefined: true;
 } | {
-    k: "undefined";
+    number: "NaN" | "Infinity" | "-Infinity";
 } | {
-    k: "number";
-    v: "NaN" | "Infinity" | "-Infinity";
+    regex: {
+        source: string;
+        flags: string;
+    };
 } | {
-    k: "array";
-    v: SerializedValue[];
+    bigint: string;
 };
 /** JSON-safe form of an expression tree. See `Expression.toJson`. */
 export type SerializedExpression = {
-    t: "empty";
+    type: "empty";
 } | {
-    t: "not-parsable";
+    type: "not-parsable";
+    reason?: string;
 } | {
-    t: "operator";
+    type: "operator";
     operator: Operator;
     left?: SerializedExpression;
     right?: SerializedExpression;
 } | {
-    t: "comparator";
+    type: "comparator";
     comparator: Comparator;
     negated: boolean;
     strict: boolean;
     left?: SerializedExpression;
     right?: SerializedExpression;
 } | {
-    t: "property";
+    type: "call";
+    call: Call;
+    expression: SerializedExpression;
+    arguments: SerializedExpression[];
+} | {
+    type: "property";
     path: string;
-    transformer: Transformer | null;
-    locale: string | null;
 } | {
-    t: "value";
+    type: "value";
     value: SerializedValue;
-    transformer: Transformer | null;
-    locale: string | null;
 };
 export type ParsedExpression = {
     expression: Expression;
@@ -65,6 +66,8 @@ export declare abstract class Expression {
     constructor(left?: Expression, right?: Expression);
     static get EMPTY(): EmptyExpression;
     static get NOT_PARSABLE(): NotParsableExpression;
+    /** `NOT_PARSABLE`, carrying what the parser refused. */
+    static notParsable(reason: string): NotParsableExpression;
     static isEmpty(expression: Expression): boolean;
     static isNotParsable(expression: Expression): boolean;
     /**
@@ -77,7 +80,7 @@ export declare abstract class Expression {
      *
      * ## Why it is this small
      *
-     * Of the six node types a bound tree can contain, exactly one holds anything JSON cannot carry:
+     * Of the seven node types a bound tree can contain, exactly one holds anything JSON cannot carry:
      * `PropertyExpression`, whose live `PropertyInfo` has functions, a parent chain and caches. It
      * reduces to a property PATH — `PropertyInfo.id` IS the dotted path, and `getProperty` is keyed by
      * exactly that — so rebinding is one lookup.
@@ -109,6 +112,9 @@ export declare class EmptyExpression extends Expression {
 }
 export declare class NotParsableExpression extends Expression {
     readonly type: "not-parsable";
+    /** What the parser refused, when it knows. `.explain()` prints it beside the source. */
+    readonly reason?: string;
+    constructor(reason?: string);
 }
 /**
  * A class representing a comparison operation (e.g., equals, greater-than).
@@ -152,12 +158,22 @@ export declare class PropertyExpression extends Expression {
     readonly type: "property";
     /** The property info for the path. */
     property: PropertyInfo<any>;
-    transformer: Transformer | null;
-    locale: string | null;
     constructor(options: {
         property: PropertyInfo<any>;
     });
 }
+export declare class CallExpression extends Expression {
+    readonly type: "call";
+    call: Call;
+    expression: Expression;
+    /** Empty for a unary call. */
+    arguments: Expression[];
+    constructor(options: {
+        call: Call;
+        expression: Expression;
+        arguments?: Expression[];
+    });
+}
 /**
  * A class representing a literal value.
  */
@@ -166,8 +182,6 @@ export declare class ValueExpression extends Expression {
     readonly type: "value";
     /** The literal value. */
     value: unknown;
-    transformer: Transformer | null;
-    locale: string | null;
     constructor(options: {
         value: unknown;
     });
@@ -175,12 +189,17 @@ export declare class ValueExpression extends Expression {
 /**
  * The set of possible expression types.
  */
-export type ExpressionType = "operator" | "comparator" | "property" | "value" | "empty" | "not-parsable";
+export type ExpressionType = "operator" | "comparator" | "property" | "value" | "call" | "empty" | "not-parsable";
 /**
  * Supported value transformations that can be applied to values.
  * `length` reads the length of a string or array property.
  */
 export type Transformer = "to-lower-case" | "to-upper-case" | "length";
+/**
+ * The names claimed so far. A name absent here is not refused — `specs/filter-expressions.md` lists
+ * both the refusals and their reasons, and is longer than this union.
+ */
+export type Call = "to-lower-case" | "to-upper-case" | "length" | "trim" | "trim-start" | "trim-end" | "index-of" | "substring" | "concat" | "replace" | "replace-all" | "absolute" | "floor" | "ceiling" | "round" | "sign" | "square-root" | "power" | "add" | "subtract" | "multiply" | "divide" | "modulo" | "utc-year" | "utc-month" | "utc-day-of-month" | "utc-day-of-week" | "utc-hour" | "utc-minute" | "utc-second" | "utc-millisecond" | "epoch-ms" | "to-string" | "to-number" | "to-boolean" | "type-of" | "some" | "every" | "power" | "bit-and" | "bit-or" | "bit-xor" | "bit-not" | "shift-left" | "shift-right" | "shift-right-unsigned" | "conditional" | "coalesce" | "matches";
 /**
  * Supported comparator operations for expressions.
  */

package/dist/expressions/utils.d.ts

@@ -1,5 +1,23 @@
 import { PropertyInfo } from "../schema";
-import { Expression } from "./types";
+import { CallExpression, Expression } from "./types";
+/**
+ * An operand with the calls wrapping it, innermost first — the order they are applied in.
+ *
+ * The nodes rather than their names: a binary call carries arguments, and a consumer that only knows
+ * the name renders `LOWER(col)` correctly and `col + ?` not at all.
+ */
+export type PeeledOperand = {
+    operand: Expression;
+    calls: CallExpression[];
+};
+/**
+ * Separates an operand from the calls applied to it.
+ *
+ * `null` when there is no operand beneath the calls. Every consumer needs this to decide whether a
+ * comparator side is a property or a value, so it lives here rather than in each translator.
+ */
+export declare function peelCalls(expression: Expression | undefined): PeeledOperand | null;
+export declare function childrenOf(expression: Expression): Expression[];
 /**
  * Extracts all properties referenced in an expression
  * @param expression The expression to analyze