rado 0.3.4 → 0.3.6

package/dist/src/lib/Expr.js

@@ -1,284 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-
-// src/lib/Expr.ts
-import { OrderDirection } from "./OrderBy.js";
-import { ParamData, ParamType } from "./Param.js";
-import { Target } from "./Target.js";
-var UnOp = /* @__PURE__ */ ((UnOp2) => {
-  UnOp2["Not"] = "Not";
-  UnOp2["IsNull"] = "IsNull";
-  return UnOp2;
-})(UnOp || {});
-var BinOp = /* @__PURE__ */ ((BinOp2) => {
-  BinOp2["Add"] = "Add";
-  BinOp2["Subt"] = "Subt";
-  BinOp2["Mult"] = "Mult";
-  BinOp2["Mod"] = "Mod";
-  BinOp2["Div"] = "Div";
-  BinOp2["Greater"] = "Greater";
-  BinOp2["GreaterOrEqual"] = "GreaterOrEqual";
-  BinOp2["Less"] = "Less";
-  BinOp2["LessOrEqual"] = "LessOrEqual";
-  BinOp2["Equals"] = "Equals";
-  BinOp2["NotEquals"] = "NotEquals";
-  BinOp2["And"] = "And";
-  BinOp2["Or"] = "Or";
-  BinOp2["Like"] = "Like";
-  BinOp2["Glob"] = "Glob";
-  BinOp2["Match"] = "Match";
-  BinOp2["In"] = "In";
-  BinOp2["NotIn"] = "NotIn";
-  BinOp2["Concat"] = "Concat";
-  return BinOp2;
-})(BinOp || {});
-var ExprType = /* @__PURE__ */ ((ExprType2) => {
-  ExprType2["UnOp"] = "UnOp";
-  ExprType2["BinOp"] = "BinOp";
-  ExprType2["Field"] = "Field";
-  ExprType2["Param"] = "Param";
-  ExprType2["Call"] = "Call";
-  ExprType2["Query"] = "Query";
-  ExprType2["Record"] = "Record";
-  ExprType2["Row"] = "Row";
-  ExprType2["Map"] = "Map";
-  ExprType2["Filter"] = "Filter";
-  ExprType2["Merge"] = "Merge";
-  ExprType2["Case"] = "Case";
-  return ExprType2;
-})(ExprType || {});
-var ExprData = {
-  UnOp(op, expr) {
-    return { type: "UnOp" /* UnOp */, op, expr };
-  },
-  BinOp(op, a, b) {
-    return { type: "BinOp" /* BinOp */, op, a, b };
-  },
-  Field(expr, field) {
-    return { type: "Field" /* Field */, expr, field };
-  },
-  Param(param) {
-    return { type: "Param" /* Param */, param };
-  },
-  Call(method, params) {
-    return { type: "Call" /* Call */, method, params };
-  },
-  Query(query) {
-    return { type: "Query" /* Query */, query };
-  },
-  Record(fields) {
-    return { type: "Record" /* Record */, fields };
-  },
-  Merge(a, b) {
-    return { type: "Merge" /* Merge */, a, b };
-  },
-  Row(target) {
-    return { type: "Row" /* Row */, target };
-  },
-  Map(target, result) {
-    return { type: "Map" /* Map */, target, result };
-  },
-  Filter(target, condition) {
-    return { type: "Filter" /* Filter */, target, condition };
-  },
-  Case(expr, cases, defaultCase) {
-    return { type: "Case" /* Case */, expr, cases, defaultCase };
-  },
-  create(input) {
-    if (input === null || input === void 0)
-      return ExprData.Param(ParamData.Value(null));
-    if (input && typeof input === "object" && typeof input.toExpr === "function")
-      input = input.toExpr();
-    if (input instanceof Expr)
-      return input.expr;
-    if (input && typeof input === "object" && !Array.isArray(input))
-      return ExprData.Record(
-        Object.fromEntries(
-          Object.entries(input).map(([key, value]) => [
-            key,
-            ExprData.create(value)
-          ])
-        )
-      );
-    return ExprData.Param(ParamData.Value(input));
-  }
-};
-var toExpr = ExprData.create;
-function isConstant(e, value) {
-  switch (e.type) {
-    case "Param" /* Param */:
-      switch (e.param.type) {
-        case ParamType.Value:
-          return e.param.value == value;
-        default:
-          return false;
-      }
-    default:
-      return false;
-  }
-}
-var _Expr = class {
-  constructor(expr) {
-    this.expr = expr;
-    return new Proxy(this, {
-      get(target, key) {
-        return key in target ? target[key] : target.get(key);
-      }
-    });
-  }
-  static value(value) {
-    return new _Expr(ExprData.Param(ParamData.Value(value)));
-  }
-  static create(input) {
-    if (input instanceof _Expr)
-      return input;
-    return new _Expr(ExprData.create(input));
-  }
-  static and(...conditions) {
-    return conditions.map(_Expr.create).reduce((condition, expr) => condition.and(expr), _Expr.value(true));
-  }
-  static or(...conditions) {
-    return conditions.map(_Expr.create).reduce((condition, expr) => condition.or(expr), _Expr.value(false));
-  }
-  asc() {
-    return { expr: this.expr, order: OrderDirection.Asc };
-  }
-  desc() {
-    return { expr: this.expr, order: OrderDirection.Desc };
-  }
-  not() {
-    return unop(this, "Not" /* Not */);
-  }
-  or(that) {
-    const a = this.expr;
-    const b = toExpr(that);
-    if (isConstant(b, true) || isConstant(a, false))
-      return new _Expr(b);
-    if (isConstant(a, true) || isConstant(b, false))
-      return this;
-    return new _Expr(ExprData.BinOp("Or" /* Or */, a, b));
-  }
-  and(that) {
-    const a = this.expr;
-    const b = toExpr(that);
-    if (isConstant(b, true) || isConstant(a, false))
-      return this;
-    if (isConstant(a, true) || isConstant(b, false))
-      return new _Expr(b);
-    return new _Expr(ExprData.BinOp("And" /* And */, a, b));
-  }
-  isNull() {
-    return unop(this, "IsNull" /* IsNull */);
-  }
-  isNotNull() {
-    return this.isNull().not();
-  }
-  isNot(that) {
-    if (that == null || that instanceof _Expr && isConstant(that.expr, null))
-      return this.isNotNull();
-    return binop(this, "NotEquals" /* NotEquals */, that);
-  }
-  is(that) {
-    if (that === null || that instanceof _Expr && isConstant(that.expr, null))
-      return this.isNull();
-    return binop(this, "Equals" /* Equals */, that);
-  }
-  isIn(that) {
-    return binop(this, "In" /* In */, that);
-  }
-  isNotIn(that) {
-    return binop(this, "NotIn" /* NotIn */, that);
-  }
-  add(that) {
-    return binop(this, "Add" /* Add */, that);
-  }
-  substract(that) {
-    return binop(this, "Subt" /* Subt */, that);
-  }
-  multiply(that) {
-    return binop(this, "Mult" /* Mult */, that);
-  }
-  remainder(that) {
-    return binop(this, "Mod" /* Mod */, that);
-  }
-  divide(that) {
-    return binop(this, "Div" /* Div */, that);
-  }
-  greater(that) {
-    return binop(this, "Greater" /* Greater */, that);
-  }
-  greaterOrEqual(that) {
-    return binop(this, "GreaterOrEqual" /* GreaterOrEqual */, that);
-  }
-  less(that) {
-    return binop(this, "Less" /* Less */, that);
-  }
-  lessOrEqual(that) {
-    return binop(this, "LessOrEqual" /* LessOrEqual */, that);
-  }
-  concat(that) {
-    return binop(this, "Concat" /* Concat */, that);
-  }
-  like(that) {
-    return binop(this, "Like" /* Like */, that);
-  }
-  glob(that) {
-    return binop(this, "Glob" /* Glob */, that);
-  }
-  match(that) {
-    return binop(this, "Match" /* Match */, that);
-  }
-  with(that) {
-    return new _Expr(
-      ExprData.Merge(this.expr, ExprData.create(that))
-    );
-  }
-  at(index) {
-    return this.get(`[${Number(index)}]`);
-  }
-  filter(fn) {
-    const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Each(this.expr, alias);
-    return new _Expr(
-      ExprData.Filter(
-        target,
-        ExprData.create(fn(new _Expr(ExprData.Row(target))))
-      )
-    );
-  }
-  map(fn) {
-    const alias = `__${Math.random().toString(36).slice(2, 9)}`;
-    const target = Target.Each(this.expr, alias);
-    return new _Expr(
-      ExprData.Map(
-        target,
-        ExprData.create(fn(new _Expr(ExprData.Row(target))))
-      )
-    );
-  }
-  sure() {
-    return this;
-  }
-  get(name) {
-    return new _Expr(ExprData.Field(this.expr, name));
-  }
-};
-var Expr = _Expr;
-__publicField(Expr, "NULL", toExpr(null));
-function unop(self, type) {
-  return new Expr(ExprData.UnOp(type, self.expr));
-}
-function binop(self, type, that) {
-  return new Expr(ExprData.BinOp(type, self.expr, toExpr(that)));
-}
-export {
-  BinOp,
-  Expr,
-  ExprData,
-  ExprType,
-  UnOp
-};