rado 0.4.0 → 0.4.2

package/dist/define/Expr.d.ts

@@ -112,6 +112,7 @@ export declare namespace ExprData {
         constructor(target: Target, condition: ExprData);
     }
     function create(input: any): ExprData;
+    function createAll(...inputs: Array<any>): Array<ExprData>;
 }
 /** Expression or value of type T */
 export type EV<T> = Expr<T> | T;
@@ -137,12 +138,12 @@ export declare class Expr<T> {
     isGreaterOrEqual(that: EV<any>): Expr<boolean>;
     isLess(that: EV<any>): Expr<boolean>;
     isLessOrEqual(that: EV<any>): Expr<boolean>;
-    add(this: Expr<number>, that: EV<number>): Expr<number>;
-    subtract(this: Expr<number>, that: EV<number>): Expr<number>;
-    multiply(this: Expr<number>, that: EV<number>): Expr<number>;
+    add(this: Expr<number>, that: EV<number>, ...rest: Array<EV<number>>): Expr<number>;
+    subtract(this: Expr<number>, that: EV<number>, ...rest: Array<EV<number>>): Expr<number>;
+    multiply(this: Expr<number>, that: EV<number>, ...rest: Array<EV<number>>): Expr<number>;
     remainder(this: Expr<number>, that: EV<number>): Expr<number>;
-    divide(this: Expr<number>, that: EV<number>): Expr<number>;
-    concat(this: Expr<string>, that: EV<string>): Expr<string>;
+    divide(this: Expr<number>, that: EV<number>, ...rest: Array<EV<number>>): Expr<number>;
+    concat(this: Expr<string>, that: EV<string>, ...rest: Array<EV<string>>): Expr<string>;
     like(this: Expr<string>, that: EV<string>): Expr<boolean>;
     glob(this: Expr<string>, that: EV<string>): Expr<boolean>;
     match(this: Expr<string>, that: EV<string>): Expr<boolean>;

package/dist/define/Expr.js

@@ -147,6 +147,10 @@ var ExprData;
     return new ExprData2.Param(new ParamData.Value(input));
   }
   ExprData2.create = create;
+  function createAll(...inputs) {
+    return inputs.map(create);
+  }
+  ExprData2.createAll = createAll;
 })(ExprData || (ExprData = {}));
 class Expr {
   constructor(expr) {
@@ -273,19 +277,25 @@ class Expr {
       )
     );
   }
-  add(that) {
+  add(that, ...rest) {
     return new Expr(
-      new ExprData.BinOp("Add" /* Add */, this[Expr.Data], ExprData.create(that))
+      ExprData.createAll(this, that, ...rest).reduce(
+        (a, b) => new ExprData.BinOp("Add" /* Add */, a, b)
+      )
     );
   }
-  subtract(that) {
+  subtract(that, ...rest) {
     return new Expr(
-      new ExprData.BinOp("Subt" /* Subt */, this[Expr.Data], ExprData.create(that))
+      ExprData.createAll(this, that, ...rest).reduce(
+        (a, b) => new ExprData.BinOp("Subt" /* Subt */, a, b)
+      )
     );
   }
-  multiply(that) {
+  multiply(that, ...rest) {
     return new Expr(
-      new ExprData.BinOp("Mult" /* Mult */, this[Expr.Data], ExprData.create(that))
+      ExprData.createAll(this, that, ...rest).reduce(
+        (a, b) => new ExprData.BinOp("Mult" /* Mult */, a, b)
+      )
     );
   }
   remainder(that) {
@@ -293,17 +303,17 @@ class Expr {
       new ExprData.BinOp("Mod" /* Mod */, this[Expr.Data], ExprData.create(that))
     );
   }
-  divide(that) {
+  divide(that, ...rest) {
     return new Expr(
-      new ExprData.BinOp("Div" /* Div */, this[Expr.Data], ExprData.create(that))
+      ExprData.createAll(this, that, ...rest).reduce(
+        (a, b) => new ExprData.BinOp("Div" /* Div */, a, b)
+      )
     );
   }
-  concat(that) {
+  concat(that, ...rest) {
     return new Expr(
-      new ExprData.BinOp(
-        "Concat" /* Concat */,
-        this[Expr.Data],
-        ExprData.create(that)
+      ExprData.createAll(this, that, ...rest).reduce(
+        (a, b) => new ExprData.BinOp("Concat" /* Concat */, a, b)
       )
     );
   }

package/dist/define/Ops.d.ts

@@ -16,16 +16,16 @@ export declare const isGreater: <T>(a: EV<T>, b: EV<T>) => Expr<boolean>;
 export declare const isGreaterOrEqual: <T>(a: EV<T>, b: EV<T>) => Expr<boolean>;
 export declare const isLess: <T>(a: EV<T>, b: EV<T>) => Expr<boolean>;
 export declare const isLessOrEqual: <T>(a: EV<T>, b: EV<T>) => Expr<boolean>;
-export declare const add: <T extends number>(a: EV<T>, b: EV<T>) => Expr<number>;
-export declare const subtract: <T extends number>(a: EV<T>, b: EV<T>) => Expr<number>;
-export declare const multiply: <T extends number>(a: EV<T>, b: EV<T>) => Expr<number>;
-export declare const divide: <T extends number>(a: EV<T>, b: EV<T>) => Expr<number>;
-export declare const remainder: <T extends number>(a: EV<T>, b: EV<T>) => Expr<number>;
-export declare const concat: <T extends string>(a: EV<T>, b: EV<T>) => Expr<string>;
-export declare const like: <T extends string>(a: EV<T>, b: EV<T>) => Expr<boolean>;
-export declare const glob: <T extends string>(a: EV<T>, b: EV<T>) => Expr<boolean>;
-export declare const at: <T extends string>(a: EV<T[]>, index: number) => Expr<T | null>;
-export declare const includes: <T extends string>(a: EV<T[]>, value: EV<T>) => Expr<boolean>;
+export declare const add: (a: EV<number>, b: EV<number>, ...rest: Array<EV<number>>) => Expr<number>;
+export declare const subtract: (a: EV<number>, b: EV<number>, ...rest: Array<EV<number>>) => Expr<number>;
+export declare const multiply: (a: EV<number>, b: EV<number>, ...rest: Array<EV<number>>) => Expr<number>;
+export declare const divide: (a: EV<number>, b: EV<number>, ...rest: Array<EV<number>>) => Expr<number>;
+export declare const remainder: (a: EV<number>, b: EV<number>) => Expr<number>;
+export declare const concat: (a: EV<string>, b: EV<string>) => Expr<string>;
+export declare const like: (a: EV<string>, b: EV<string>) => Expr<boolean>;
+export declare const glob: (a: EV<string>, b: EV<string>) => Expr<boolean>;
+export declare const at: <T>(a: EV<T[]>, index: number) => Expr<T | null>;
+export declare const includes: <T>(a: EV<T[]>, value: EV<T>) => Expr<boolean>;
 export declare function withRecursive<Row>(initialSelect: Select<Row>): RecursiveUnion<Row>;
 export declare function alias<T extends Table<{}>>(table: T): Record<string, T>;
 export declare function select<X extends Selection>(selection: X): Select<Selection.Infer<X>>;

package/dist/define/Ops.js

@@ -26,10 +26,10 @@ const isGreater = (a, b) => Expr.create(a).isGreater(b);
 const isGreaterOrEqual = (a, b) => Expr.create(a).isGreaterOrEqual(b);
 const isLess = (a, b) => Expr.create(a).isLess(b);
 const isLessOrEqual = (a, b) => Expr.create(a).isLessOrEqual(b);
-const add = (a, b) => Expr.create(a).add(b);
-const subtract = (a, b) => Expr.create(a).subtract(b);
-const multiply = (a, b) => Expr.create(a).multiply(b);
-const divide = (a, b) => Expr.create(a).divide(b);
+const add = (a, b, ...rest) => Expr.create(a).add(b, ...rest);
+const subtract = (a, b, ...rest) => Expr.create(a).subtract(b, ...rest);
+const multiply = (a, b, ...rest) => Expr.create(a).multiply(b, ...rest);
+const divide = (a, b, ...rest) => Expr.create(a).divide(b, ...rest);
 const remainder = (a, b) => Expr.create(a).remainder(b);
 const concat = (a, b) => Expr.create(a).concat(b);
 const like = (a, b) => Expr.create(a).like(b);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",