angular-odata 0.95.0 → 0.99.0

package/lib/resources/query/expressions/base.d.ts

@@ -0,0 +1,19 @@
+import type { QueryCustomType } from '../builder';
+import { Renderable } from './syntax';
+export declare abstract class Expression<T> implements Renderable {
+    protected _children: Renderable[];
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    get [Symbol.toStringTag](): string;
+    abstract render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    children(): Renderable[];
+    length(): number;
+    toJSON(): {
+        children: any[];
+    };
+}

package/lib/resources/query/expressions/compute.d.ts

@@ -0,0 +1,26 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+export declare class ComputeExpression<T> extends Expression<T> {
+    names: string[];
+    constructor({ children, names, }?: {
+        children?: Renderable[];
+        names?: string[];
+    });
+    static e<T>(): ComputeExpression<T>;
+    static s<T extends object>(): T;
+    static compute<T extends object>(opts: (e: {
+        s: T;
+        e: () => ComputeExpression<T>;
+    }) => ComputeExpression<T>): ComputeExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    private _add;
+    field<T extends object>(name: string, opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ComputeExpression<T>;
+}

package/lib/resources/query/expressions/expand.d.ts

@@ -0,0 +1,40 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare class ExpandField<T> implements Renderable {
+    protected field: Renderable;
+    constructor(field: Renderable);
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        field: any;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+    select(): void;
+    filter(): void;
+    levels(): void;
+    orderBy(): void;
+    top(): void;
+    skip(): void;
+}
+export declare class ExpandExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    static e<T>(): ExpandExpression<T>;
+    static s<T extends object>(): T;
+    static expand<T extends object>(opts: (e: {
+        s: T;
+        e: () => ExpandExpression<T>;
+    }) => ExpandExpression<T>): ExpandExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    private _add;
+    field<T extends object>(field: any, opts?: (e: ExpandField<keyof T>) => void): ExpandExpression<T>;
+}

package/lib/resources/query/expressions/filter.d.ts

@@ -0,0 +1,58 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+export declare type FilterConnector = 'and' | 'or';
+export declare class FilterExpression<T> extends Expression<T> {
+    private _connector;
+    private _negated;
+    constructor({ children, connector, negated, }?: {
+        children?: Renderable[];
+        connector?: FilterConnector;
+        negated?: boolean;
+    });
+    static s<T extends object>(): T;
+    static e<T>(connector?: FilterConnector): FilterExpression<T>;
+    static filter<T extends object>(opts: (e: {
+        s: T;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => FilterExpression<T>): FilterExpression<T>;
+    toJSON(): {
+        children: any[];
+        connector: FilterConnector;
+        negated: boolean;
+    };
+    connector(): FilterConnector;
+    negated(): boolean;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+    private _add;
+    or(exp: FilterExpression<T>): FilterExpression<T>;
+    and(exp: FilterExpression<T>): FilterExpression<T>;
+    not(exp: FilterExpression<T>): FilterExpression<T>;
+    eq(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    ne(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    gt(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    ge(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    lt(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    le(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    has(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    in(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    contains(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    startsWith(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    endsWith(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    any<N extends object>(left: N[], opts: (e: {
+        s: N;
+        e: (connector?: FilterConnector) => FilterExpression<N>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<T>;
+    all<N extends object>(left: N[], opts: (e: {
+        s: N;
+        e: (connector?: FilterConnector) => FilterExpression<N>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<T>;
+    isof(type: string): FilterExpression<T>;
+    isof(left: T, type: string): FilterExpression<T>;
+}

package/lib/resources/query/expressions/index.d.ts

@@ -0,0 +1,6 @@
+export * from './base';
+export * from './compute';
+export * from './filter';
+export * from './orderby';
+export * from './search';
+export * from './syntax';

package/lib/resources/query/expressions/orderby.d.ts

@@ -0,0 +1,37 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare class OrderByField implements Renderable {
+    protected field: Renderable;
+    protected order: 'asc' | 'desc';
+    constructor(field: Renderable, order: 'asc' | 'desc');
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        field: any;
+        order: "desc" | "asc";
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+}
+export declare class OrderByExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    static e<T>(): OrderByExpression<T>;
+    static s<T extends object>(): T;
+    static orderBy<T extends object>(opts: (e: {
+        s: T;
+        e: () => OrderByExpression<T>;
+    }) => OrderByExpression<T>): OrderByExpression<T>;
+    private _add;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    ascending(field: any): OrderByExpression<T>;
+    descending(field: any): OrderByExpression<T>;
+}

package/lib/resources/query/expressions/search.d.ts

@@ -0,0 +1,47 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare type SearchConnector = 'AND' | 'OR';
+export declare class SearchTerm implements Renderable {
+    protected value: string;
+    constructor(value: string);
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        value: string;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+}
+export declare class SearchExpression<T> extends Expression<T> {
+    private _connector;
+    private _negated;
+    constructor({ children, connector, negated, }?: {
+        children?: Renderable[];
+        connector?: SearchConnector;
+        negated?: boolean;
+    });
+    static e<T>(connector?: SearchConnector): SearchExpression<T>;
+    static search<T extends object>(opts: (e: {
+        e: (connector?: SearchConnector) => SearchExpression<T>;
+    }) => SearchExpression<T>): SearchExpression<T>;
+    private _add;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    toJSON(): {
+        children: any[];
+        connector: SearchConnector;
+        negated: boolean;
+    };
+    connector(): SearchConnector;
+    negated(): boolean;
+    or(exp: SearchExpression<T>): SearchExpression<T>;
+    and(exp: SearchExpression<T>): SearchExpression<T>;
+    not(exp: SearchExpression<T>): SearchExpression<T>;
+    term(value: any): SearchExpression<T>;
+}

package/lib/resources/query/expressions/select.d.ts

@@ -0,0 +1,21 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare class SelectExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    static e<T>(): SelectExpression<T>;
+    static s<T extends object>(): T;
+    static select<T extends object>(opts: (e: {
+        s: T;
+        e: () => SelectExpression<T>;
+    }) => SelectExpression<T>): SelectExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    private _add;
+    field(field: any): SelectExpression<T>;
+}

package/lib/resources/query/{syntax.d.ts → expressions/syntax.d.ts}

@@ -1,4 +1,4 @@
-import type { QueryCustomType } from './builder';
+import type { QueryCustomType } from '../builder';
 export interface Renderable {
     render({ aliases, escape, prefix, }: {
         aliases?: QueryCustomType[];
@@ -8,13 +8,18 @@ export interface Renderable {
     toString(): string;
     toJSON(): any;
 }
-export declare type Funcs<T> = (x: ODataSyntax<T>) => Function<T> | Operator<T> | Grouping<T>;
 export declare class Field<T extends object> implements ProxyHandler<T> {
     name: string;
     constructor(name?: string);
     static factory<T extends object>(): T;
     get(target: T, p: string | symbol): any;
 }
+export declare function render(value: any, { aliases, normalize, escape, prefix, }?: {
+    aliases?: QueryCustomType[];
+    normalize?: boolean;
+    escape?: boolean;
+    prefix?: string;
+}): string | number | boolean | null;
 export declare class Function<T> implements Renderable {
     protected name: string;
     protected values: any[];
@@ -134,9 +139,6 @@ export declare class Grouping<T> implements Renderable {
         prefix?: string;
     }): string;
 }
-export declare class GroupingOperators<T> {
-    grouping(value: any): Grouping<unknown>;
-}
 export declare class Lambda<T> implements Renderable {
     protected op: string;
     protected values: any[];
@@ -160,7 +162,7 @@ export declare class LambdaOperators<T> {
 }
 export declare class ODataOperators<T> {
 }
-export interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, GroupingOperators<T>, LambdaOperators<T> {
+export interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, LambdaOperators<T> {
 }
 export declare const operators: ODataOperators<any>;
 export declare class ODataFunctions<T> {

package/lib/resources/query/handlers.d.ts

@@ -1,8 +1,9 @@
 import { QueryOptionNames } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
-import { Connector, Expression } from './expressions';
+import { ComputeExpression, FilterConnector, FilterExpression, OrderByExpression, SearchConnector, SearchExpression, ODataFunctions, ODataOperators } from './expressions';
+import { ExpandExpression } from './expressions/expand';
+import { SelectExpression } from './expressions/select';
 import type { ODataQueryArguments, ODataQueryOptions } from './options';
-import { ODataFunctions, ODataOperators } from './syntax';
 export declare class ODataQueryOptionHandler<T> {
     private o;
     private n;
@@ -38,16 +39,27 @@ export declare class ODataQueryOptionsHandler<T> {
      * @returns The alias
      */
     alias(value: any, name?: string): import("./builder").QueryCustomType;
+    select(opts: (e: {
+        s: T;
+        e: () => SelectExpression<T>;
+    }) => SelectExpression<T>): SelectExpression<T>;
     select(opts: Select<T>): ODataQueryOptionHandler<T>;
     select(): ODataQueryOptionHandler<T>;
+    expand(opts: (e: {
+        s: T;
+        e: () => ExpandExpression<T>;
+    }) => ExpandExpression<T>): ExpandExpression<T>;
     expand(opts: Expand<T>): ODataQueryOptionHandler<T>;
     expand(): ODataQueryOptionHandler<T>;
     /**
      * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptioncompute
      */
     compute(opts: (e: {
-        e: Expression<T>;
-    }) => Expression<T>): Expression<T>;
+        s: T;
+        e: () => ComputeExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => ComputeExpression<T>): ComputeExpression<T>;
     compute(opts: string): ODataQueryOptionHandler<T>;
     compute(): ODataQueryOptionHandler<T>;
     /**
@@ -57,20 +69,23 @@ export declare class ODataQueryOptionsHandler<T> {
     format(): ODataQueryOptionHandler<T>;
     transform(opts: Transform<T>): ODataQueryOptionHandler<T>;
     transform(): ODataQueryOptionHandler<T>;
+    search(opts: (e: {
+        e: (connector: SearchConnector) => SearchExpression<T>;
+    }) => SearchExpression<T>): SearchExpression<T>;
     search(opts: string): ODataQueryOptionHandler<T>;
     search(): ODataQueryOptionHandler<T>;
     filter(opts: (e: {
         s: T;
-        e: (connector?: Connector) => Expression<T>;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
-    }) => Expression<T>): Expression<T>;
+    }) => FilterExpression<T>): FilterExpression<T>;
     filter(opts: Filter<T>): ODataQueryOptionHandler<T>;
     filter(): ODataQueryOptionHandler<T>;
     orderBy(opts: (e: {
-        e: () => Expression<T>;
-        not: (e: Expression<T>) => Expression<T>;
-    }) => Expression<T>): Expression<T>;
+        s: T;
+        e: () => OrderByExpression<T>;
+    }) => OrderByExpression<T>): OrderByExpression<T>;
     orderBy(opts: OrderBy<T>): ODataQueryOptionHandler<T>;
     orderBy(): ODataQueryOptionHandler<T>;
     top(opts: number): ODataQueryOptionHandler<T>;

package/lib/resources/types/batch.d.ts

@@ -25,6 +25,15 @@ export declare class ODataBatchResource extends ODataResource<any> {
     private _requests;
     requests(): ODataRequest<any>[];
     static factory(api: ODataApi): ODataBatchResource;
+    private storeRequester;
+    private restoreRequester;
+    /**
+     * Add to batch request
+     * @param ctx The context for the request
+     * @returns The result of execute the context
+     */
+    add<R>(ctx: (batch: this) => Observable<R>): Observable<R>;
+    send(options?: ODataOptions): void;
     /**
      * Execute the batch request
      * @param ctx The context for the request

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.95.0",
+  "version": "0.99.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {

package/esm2020/lib/resources/query/expressions.mjs

@@ -1,207 +0,0 @@
-import { Field, functions, operators, } from './syntax';
-import { syntax } from './syntax';
-export class Expression {
-    constructor({ children, connector, negated, } = {}) {
-        this._children = children || [];
-        this._connector = connector || 'and';
-        this._negated = negated || false;
-    }
-    get [Symbol.toStringTag]() {
-        return 'Expression';
-    }
-    static s() {
-        return Field.factory();
-    }
-    static e(connector = 'and') {
-        return new Expression({ connector });
-    }
-    static o() {
-        return operators;
-    }
-    static f() {
-        return functions;
-    }
-    static filter(opts) {
-        return opts({
-            s: Expression.s(),
-            e: Expression.e,
-            o: Expression.o(),
-            f: Expression.f(),
-        });
-    }
-    toJSON() {
-        return {
-            children: this._children.map((c) => c.toJSON()),
-            connector: this._connector,
-            negated: this._negated,
-        };
-    }
-    children() {
-        return this._children;
-    }
-    connector() {
-        return this._connector;
-    }
-    negated() {
-        return this._negated;
-    }
-    length() {
-        return this._children.length;
-    }
-    render({ aliases, escape, prefix, } = {}) {
-        let content = this._children
-            .map((n) => n.render({ aliases, escape, prefix }))
-            .join(` ${this._connector} `);
-        if (this._negated) {
-            content = `not (${content})`;
-        }
-        return content;
-    }
-    _add(node, connector) {
-        if (connector !== undefined && this._connector !== connector) {
-            let children = [];
-            if (this._children.length > 0) {
-                if (this._children.length === 1) {
-                    children = [...this._children];
-                }
-                else {
-                    let exp = new Expression({
-                        children: this._children,
-                        connector: this._connector,
-                        negated: this._negated,
-                    });
-                    if (exp.length() > 1) {
-                        children.push(syntax.grouping(exp));
-                    }
-                    else {
-                        children.push(exp);
-                    }
-                }
-            }
-            if (node instanceof Expression &&
-                (node.connector() === connector || node.length() === 1)) {
-                children = [...children, ...node.children()];
-            }
-            else {
-                children.push(syntax.grouping(node));
-            }
-            this._connector = connector;
-            this._children = children;
-        }
-        else if (node instanceof Expression &&
-            !node.negated() &&
-            (node.connector() === connector || node.length() === 1)) {
-            this._children = [...this._children, ...node.children()];
-        }
-        else {
-            this._children.push(node instanceof Expression && !node.negated()
-                ? syntax.grouping(node)
-                : node);
-        }
-        return this;
-    }
-    or(exp) {
-        return this._add(exp, 'or');
-    }
-    and(exp) {
-        return this._add(exp, 'and');
-    }
-    not(exp) {
-        const notExp = new Expression({
-            children: exp.children(),
-            connector: exp.connector(),
-            negated: true,
-        });
-        return this._add(notExp, this._connector);
-    }
-    eq(left, right, normalize) {
-        return this._add(operators.eq(left, right, normalize));
-    }
-    ne(left, right, normalize) {
-        return this._add(operators.ne(left, right, normalize));
-    }
-    gt(left, right, normalize) {
-        return this._add(operators.gt(left, right, normalize));
-    }
-    ge(left, right, normalize) {
-        return this._add(operators.ge(left, right, normalize));
-    }
-    lt(left, right, normalize) {
-        return this._add(operators.lt(left, right, normalize));
-    }
-    le(left, right, normalize) {
-        return this._add(operators.le(left, right, normalize));
-    }
-    has(left, right, normalize) {
-        return this._add(operators.has(left, right, normalize));
-    }
-    in(left, right, normalize) {
-        return this._add(operators.in(left, right, normalize));
-    }
-    contains(left, right, normalize) {
-        return this._add(functions.contains(left, right, normalize));
-    }
-    startsWith(left, right, normalize) {
-        return this._add(functions.startsWith(left, right, normalize));
-    }
-    endsWith(left, right, normalize) {
-        return this._add(functions.endsWith(left, right, normalize));
-    }
-    any(left, opts, alias) {
-        const exp = opts({
-            s: Field.factory(),
-            e: Expression.e,
-        });
-        return this._add(syntax.any(left, exp, alias));
-    }
-    all(left, opts, alias) {
-        const exp = opts({
-            s: Field.factory(),
-            e: Expression.e,
-        });
-        return this._add(syntax.all(left, exp, alias));
-    }
-    isof(left, type) {
-        return this._add(syntax.isof(left, type));
-    }
-}
-/*
-export class FilterExpression<T> extends Expression<T> {
-  constructor({
-    children,
-    connector,
-    negated,
-  }: {
-    children?: Renderable[];
-    connector?: Connector;
-    negated?: boolean;
-  } = {}) {
-    super({ children, connector, negated });
-  }
-
-  get [Symbol.toStringTag]() {
-    return 'FilterExpression';
-  }
-
-  static e<T>() {
-    return new FilterExpression<T>({ connector: Connector.AND });
-  }
-
-  static and<T>() {
-    return new FilterExpression<T>({ connector: Connector.AND });
-  }
-
-  static or<T>() {
-    return new FilterExpression<T>({ connector: Connector.OR });
-  }
-
-  static not<T>(exp: FilterExpression<T>) {
-    return new FilterExpression<T>({
-      children: exp.children(),
-      connector: exp.connector(),
-      negated: true,
-    });
-  }
-}
-*/
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"expressions.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/resources/query/expressions.ts"],"names":[],"mappings":"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","sourcesContent":["import type { QueryCustomType } from './builder';\nimport {\n  Field,\n  functions,\n  ODataFunctions,\n  ODataOperators,\n  operators,\n  Renderable,\n} from './syntax';\nimport { syntax } from './syntax';\n\nexport type Connector = 'and' | 'or';\n\nexport class Expression<T> implements Renderable {\n  private _connector: Connector;\n  private _negated: boolean;\n  private _children: Renderable[];\n  constructor({\n    children,\n    connector,\n    negated,\n  }: {\n    children?: Renderable[];\n    connector?: Connector;\n    negated?: boolean;\n  } = {}) {\n    this._children = children || [];\n    this._connector = connector || 'and';\n    this._negated = negated || false;\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'Expression';\n  }\n\n  static s<T extends object>(): T {\n    return Field.factory<T>();\n  }\n\n  static e<T>(connector: Connector = 'and') {\n    return new Expression<T>({ connector });\n  }\n\n  static o<T>(): ODataOperators<T> {\n    return operators;\n  }\n\n  static f<T>(): ODataFunctions<T> {\n    return functions;\n  }\n\n  static filter<T extends object>(\n    opts: (e: {\n      s: T;\n      e: (connector?: Connector) => Expression<T>;\n      o: ODataOperators<T>;\n      f: ODataFunctions<T>;\n    }) => Expression<T>\n  ): Expression<T> {\n    return opts({\n      s: Expression.s<T>(),\n      e: Expression.e,\n      o: Expression.o<T>(),\n      f: Expression.f<T>(),\n    }) as Expression<T>;\n  }\n\n  toJSON() {\n    return {\n      children: this._children.map((c) => c.toJSON()),\n      connector: this._connector,\n      negated: this._negated,\n    };\n  }\n\n  children() {\n    return this._children;\n  }\n\n  connector() {\n    return this._connector;\n  }\n\n  negated() {\n    return this._negated;\n  }\n\n  length() {\n    return this._children.length;\n  }\n\n  render({\n    aliases,\n    escape,\n    prefix,\n  }: {\n    aliases?: QueryCustomType[];\n    escape?: boolean;\n    prefix?: string;\n  } = {}): string {\n    let content = this._children\n      .map((n) => n.render({ aliases, escape, prefix }))\n      .join(` ${this._connector} `);\n    if (this._negated) {\n      content = `not (${content})`;\n    }\n    return content;\n  }\n\n  private _add(node: Renderable, connector?: Connector): Expression<T> {\n    if (connector !== undefined && this._connector !== connector) {\n      let children: Renderable[] = [];\n      if (this._children.length > 0) {\n        if (this._children.length === 1) {\n          children = [...this._children];\n        } else {\n          let exp = new Expression<T>({\n            children: this._children,\n            connector: this._connector,\n            negated: this._negated,\n          });\n          if (exp.length() > 1) {\n            children.push(syntax.grouping(exp));\n          } else {\n            children.push(exp);\n          }\n        }\n      }\n      if (\n        node instanceof Expression &&\n        (node.connector() === connector || node.length() === 1)\n      ) {\n        children = [...children, ...node.children()];\n      } else {\n        children.push(syntax.grouping(node));\n      }\n      this._connector = connector;\n      this._children = children;\n    } else if (\n      node instanceof Expression &&\n      !node.negated() &&\n      (node.connector() === connector || node.length() === 1)\n    ) {\n      this._children = [...this._children, ...node.children()];\n    } else {\n      this._children.push(\n        node instanceof Expression && !node.negated()\n          ? syntax.grouping(node)\n          : node\n      );\n    }\n    return this;\n  }\n\n  or(exp: Expression<T>): Expression<T> {\n    return this._add(exp, 'or');\n  }\n\n  and(exp: Expression<T>): Expression<T> {\n    return this._add(exp, 'and');\n  }\n\n  not(exp: Expression<T>): Expression<T> {\n    const notExp = new Expression<T>({\n      children: exp.children(),\n      connector: exp.connector(),\n      negated: true,\n    });\n\n    return this._add(notExp, this._connector);\n  }\n\n  eq(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.eq(left, right, normalize));\n  }\n\n  ne(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.ne(left, right, normalize));\n  }\n\n  gt(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.gt(left, right, normalize));\n  }\n\n  ge(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.ge(left, right, normalize));\n  }\n\n  lt(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.lt(left, right, normalize));\n  }\n\n  le(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.le(left, right, normalize));\n  }\n\n  has(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.has(left, right, normalize));\n  }\n\n  in(left: any, right: any, normalize?: boolean) {\n    return this._add(operators.in(left, right, normalize));\n  }\n\n  contains(left: any, right: any, normalize?: boolean) {\n    return this._add(functions.contains(left, right, normalize));\n  }\n\n  startsWith(left: any, right: any, normalize?: boolean) {\n    return this._add(functions.startsWith(left, right, normalize));\n  }\n\n  endsWith(left: any, right: any, normalize?: boolean) {\n    return this._add(functions.endsWith(left, right, normalize));\n  }\n\n  any<N extends object>(\n    left: N[],\n    opts: (e: {\n      s: N;\n      e: (connector?: Connector) => Expression<N>;\n    }) => Expression<N>,\n    alias?: string\n  ): Expression<T> {\n    const exp = opts({\n      s: Field.factory<N>(),\n      e: Expression.e,\n    }) as Expression<N>;\n    return this._add(syntax.any(left, exp, alias));\n  }\n\n  all<N extends object>(\n    left: N[],\n    opts: (e: {\n      s: N;\n      e: (connector?: Connector) => Expression<N>;\n    }) => Expression<N>,\n    alias?: string\n  ): Expression<T> {\n    const exp = opts({\n      s: Field.factory<N>(),\n      e: Expression.e,\n    }) as Expression<N>;\n    return this._add(syntax.all(left, exp, alias));\n  }\n\n  isof(type: string): Expression<T>;\n  isof(left: T, type: string): Expression<T>;\n  isof(left: any, type?: string): Expression<T> {\n    return this._add(syntax.isof(left, type));\n  }\n}\n\n/*\nexport class FilterExpression<T> extends Expression<T> {\n  constructor({\n    children,\n    connector,\n    negated,\n  }: {\n    children?: Renderable[];\n    connector?: Connector;\n    negated?: boolean;\n  } = {}) {\n    super({ children, connector, negated });\n  }\n\n  get [Symbol.toStringTag]() {\n    return 'FilterExpression';\n  }\n\n  static e<T>() {\n    return new FilterExpression<T>({ connector: Connector.AND });\n  }\n\n  static and<T>() {\n    return new FilterExpression<T>({ connector: Connector.AND });\n  }\n\n  static or<T>() {\n    return new FilterExpression<T>({ connector: Connector.OR });\n  }\n\n  static not<T>(exp: FilterExpression<T>) {\n    return new FilterExpression<T>({\n      children: exp.children(),\n      connector: exp.connector(),\n      negated: true,\n    });\n  }\n}\n*/\n"]}