alinea/dist/core/pages/Expr.js

[](https://npmjs.org/package/alinea) [](https://packagephobia.com/result?p=alinea)

import "../../chunks/chunk-U5RRZUYZ.js";

// src/core/pages/Expr.ts
import { createExprData } from "./CreateExprData.js";
import { createSelection } from "./CreateSelection.js";
import { OrderDirection } from "./Cursor.js";
import { BinaryOp, ExprData, UnaryOp } from "./ExprData.js";
function Expr(expr) {
  return new ExprI(expr);
}
var ExprI = class {
  constructor(expr) {
    this[Expr.Data] = expr;
    this[Expr.IsExpr] = true;
  }
  asc() {
    return { expr: this[Expr.Data], order: OrderDirection.Asc };
  }
  desc() {
    return { expr: this[Expr.Data], order: OrderDirection.Desc };
  }
  not() {
    return Expr(ExprData.UnOp(UnaryOp.Not, this[Expr.Data]));
  }
  or(...that) {
    let res = this;
    if (this.isConstant(true))
      return res;
    for (const e of that) {
      const expr = Expr.create(e);
      if (expr.isConstant(true))
        return expr;
      if (expr.isConstant(false))
        continue;
      res = Expr(ExprData.BinOp(res[Expr.Data], BinaryOp.Or, expr[Expr.Data]));
    }
    return res;
  }
  and(...that) {
    let res = this;
    if (this.isConstant(false))
      return res;
    for (const e of that) {
      const expr = Expr.create(e);
      if (expr.isConstant(false))
        return expr;
      if (expr.isConstant(true))
        continue;
      res = Expr(ExprData.BinOp(res[Expr.Data], BinaryOp.And, expr[Expr.Data]));
    }
    return res;
  }
  is(that) {
    if (that === null || Expr.isExpr(that) && that.isConstant(null))
      return this.isNull();
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.Equals, createExprData(that))
    );
  }
  isConstant(value) {
    const expr = this[Expr.Data];
    switch (expr.type) {
      case "value":
        return expr.value === value;
      default:
        return false;
    }
  }
  isNot(that) {
    if (that === null || Expr.isExpr(that) && that.isConstant(null))
      return this.isNotNull();
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.NotEquals, createExprData(that))
    );
  }
  isNull() {
    return Expr(ExprData.UnOp(UnaryOp.IsNull, this[Expr.Data]));
  }
  isNotNull() {
    return this.isNull().not();
  }
  isIn(that) {
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.In, createExprData(that))
    );
  }
  isNotIn(that) {
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.NotIn, createExprData(that))
    );
  }
  isGreater(that) {
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.Greater, createExprData(that))
    );
  }
  isGreaterOrEqual(that) {
    return Expr(
      ExprData.BinOp(
        this[Expr.Data],
        BinaryOp.GreaterOrEqual,
        createExprData(that)
      )
    );
  }
  isLess(that) {
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.Less, createExprData(that))
    );
  }
  isLessOrEqual(that) {
    return Expr(
      ExprData.BinOp(
        this[Expr.Data],
        BinaryOp.LessOrEqual,
        createExprData(that)
      )
    );
  }
  add(that) {
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.Add, createExprData(that))
    );
  }
  substract(that) {
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.Subt, createExprData(that))
    );
  }
  multiply(that) {
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.Mult, createExprData(that))
    );
  }
  remainder(that) {
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.Mod, createExprData(that))
    );
  }
  divide(that) {
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.Div, createExprData(that))
    );
  }
  concat(that) {
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.Concat, createExprData(that))
    );
  }
  like(that) {
    return Expr(
      ExprData.BinOp(this[Expr.Data], BinaryOp.Like, createExprData(that))
    );
  }
  /*dynamic<X = T>(...path: Array<string>): Fields<X> {
    return new Proxy<any>(
      (...args: Array<any>) => {
        const method = path[path.length - 1]
        const e: any =
          path.length > 1 ? this.get(path.slice(0, -1).join('.')) : this
        return e[method]?.apply(e, args)
      },
      {
        get: (_, key) => {
          const e: any = path.length > 0 ? this.get(path.join('.')) : this
          if (typeof key !== 'string') return e[key]
          return this.dynamic(...path, key)
        }
      }
    )
  }*/
  when(expr, select) {
    return new CaseBuilder(this).when(expr, select);
  }
  at(index) {
    return this.get(`[${Number(index)}]`);
  }
  includes(value) {
    return Expr(createExprData(value)).isIn(this);
  }
  sure() {
    return this;
  }
  get(name) {
    return Expr(ExprData.Access(this[Expr.Data], name));
  }
  toJSON() {
    return this[Expr.Data];
  }
};
var CaseBuilder = class _CaseBuilder {
  constructor(expr, cases = []) {
    this.expr = expr;
    this.cases = cases;
  }
  when(expr, select) {
    return new _CaseBuilder(
      this.expr,
      this.cases.concat([
        [Expr.create(expr)[Expr.Data], createSelection(select)]
      ])
    );
  }
  orElse(select) {
    return Expr(
      ExprData.Case(this.expr[Expr.Data], this.cases, createSelection(select))
    );
  }
  end() {
    return Expr(ExprData.Case(this.expr[Expr.Data], this.cases));
  }
};
function and(...conditions) {
  return conditions.map(Expr.create).reduce(
    (condition, expr) => condition.and(expr),
    Expr(ExprData.Value(true))
  );
}
function or(...conditions) {
  return conditions.map(Expr.create).reduce(
    (condition, expr) => condition.or(expr),
    Expr(ExprData.Value(false))
  );
}
((Expr2) => {
  Expr2.Data = Symbol.for("@alinea/Expr.Data");
  Expr2.IsExpr = Symbol.for("@alinea/Expr.IsExpr");
  Expr2.ToExpr = Symbol.for("@alinea/Expr.ToExpr");
  Expr2.NULL = create(null);
  function create(input) {
    if (isExpr(input))
      return input;
    return Expr2(ExprData.Value(input));
  }
  Expr2.create = create;
  function hasExpr(input) {
    return input && (typeof input === "function" || typeof input === "object") && input[Expr2.ToExpr];
  }
  Expr2.hasExpr = hasExpr;
  function isExpr(input) {
    return input !== null && (typeof input === "object" || typeof input === "function") && input[Expr2.IsExpr];
  }
  Expr2.isExpr = isExpr;
})(Expr || (Expr = {}));
export {
  CaseBuilder,
  Expr,
  ExprI,
  and,
  or
};