Merge pull request #15 from dreambo8563/release

stream

Author: dreambo8563

CHANGELOG.md

@@ -1,3 +1,18 @@
+<a name="1.0.6"></a>
+## [1.0.6](https://github.com/dreambo8563/vue-lazy-calc/compare/v1.0.5...v1.0.6) (2019-03-19)
+
+
+
+<a name="1.0.5"></a>
+## [1.0.5](https://github.com/dreambo8563/vue-lazy-calc/compare/v1.0.4...v1.0.5) (2019-03-19)
+
+
+### Features
+
+* **stream:** basic stream class with add/default operator ([9ccbc2d](https://github.com/dreambo8563/vue-lazy-calc/commit/9ccbc2d))
+
+
+
 <a name="1.0.4"></a>
 ## [1.0.4](https://github.com/dreambo8563/vue-lazy-calc/compare/v1.0.3...v1.0.4) (2019-03-19)
 

README.md

@@ -21,6 +21,11 @@ this is a just support simple calculation in lazy way.
 - lazy evaluation
 - chaining methods
 
+### TODO
+
+- [] seperate simple lazy class and base class
+- [] support more operator in stream api
+
 ### Install
 
 ```cmd
@@ -42,27 +47,55 @@ Vue.use(lzCalc)
 ### API list
 
 ```ts
-interface ILazyCalc {
-  lazy(init?: number): ILazyCalc
-  add(number: number): ILazyCalc
-  subtract(number: number): ILazyCalc
-  divide(y: number): ILazyCalc
-  multiply(y: number): ILazyCalc
-  round(precision?: number): ILazyCalc
-  floor(precision?: number): ILazyCalc
-  ceil(precision?: number): ILazyCalc
-  do(fn: operatorFunc): ILazyCalc
-  default(fallback: any): ILazyCalc
-  value(fallback?: any): any
+interface LazyCalc {
+  lazy(init?: number): LazyCalc
+  add(y: number): LazyCalc
+  divide(y: number): LazyCalc
+  subtract(y: number): LazyCalc
+  multiply(y: number): LazyCalc
+  do(fn: operatorFunc): LazyCalc
+  ceil(precision?: number): LazyCalc
+  floor(precision?: number): LazyCalc
+  round(precision?: number): LazyCalc
+  stream(s: LazyCalc): LazyStream
+  default(fallback: any): LazyCalc
+  value(): any
 }
 ```
 
 - lazy => init a new instance with optional initValue
-- add/subtract/divide/multiple => + - \* / (simple calculation)
+- add/subtract/divide/multiple => + - \* / (simple calculation) between numbers
 - round/floor/ceil => deal with precision of the float number
-- value => excute the declared method chain with optional fallBack value(if the result is NaN)
+- value => excute the declared method chain
 - default => set default value if previous operations get NaN
 - do => accept a custormized function for the number
+- stream => init a stream to operate between multiple lazy instance with optional init instantce
+
+#### Stream
+
+```ts
+declare class LazyStream {
+  add(y: LazyCalc): LazyStream
+  default(fallback: any): LazyStream
+  value(): any
+}
+```
+
+- add
+
+```js
+const result = this.$lzCalc
+  .lazy(1)
+  .add(3)
+  .multiply(2)
+  .divide(3)
+  .round(2)
+
+const tmp = this.$lzCalc.lazy(2).add(3)
+const s = this.$lzCalc.stream(result).add(tmp)
+
+console.log(s.value()) // 2.67 + 5 => 7.67
+```
 
 ### Examples
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "vue-lazy-calc",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "private": false,
   "author": "dreambo8563",
   "main": "dist/vue-lazy-calc.umd.min.js",

package.json

@@ -1,7 +1,8 @@
 import Vue, { VueConstructor } from "vue";
+import LazyStream from "./stream";
 export type operatorFunc = (i: number | string) => number;
 type CalcMethod = "ceil" | "floor" | "round";
-class LazyCalc {
+export class LazyCalc {
   initValue: number = 0;
   operators: operatorFunc[];
   private compose = (fns: operatorFunc[]) =>
@@ -59,13 +60,6 @@ class LazyCalc {
 
     return this.clone([operation, ...this.operators]);
   }
-  do(fn: operatorFunc): LazyCalc {
-    const operation = function(y: number | string) {
-      return fn(+y);
-    };
-    // this.operators.unshift(operation);
-    return this.clone([operation, ...this.operators]);
-  }
   divide(y: number): LazyCalc {
     const operation = function(x: number | string) {
       if (Number.isNaN(+x) || Number.isNaN(+y)) {
@@ -97,54 +91,46 @@ class LazyCalc {
     // this.operators.unshift(operation);
     return this.clone([operation, ...this.operators]);
   }
+  do(fn: operatorFunc): LazyCalc {
+    const operation = function(y: number | string) {
+      return fn(+y);
+    };
+    // this.operators.unshift(operation);
+    return this.clone([operation, ...this.operators]);
+  }
   ceil(precision: number = 0): LazyCalc {
     const operation = this.createRound("ceil", precision);
-    // this.operators.unshift(operation);
     return this.clone([operation, ...this.operators]);
   }
   floor(precision: number = 0): LazyCalc {
     const operation = this.createRound("floor", precision);
-    // this.operators.unshift(operation);
     return this.clone([operation, ...this.operators]);
   }
   round(precision: number = 0): LazyCalc {
     const operation = this.createRound("round", precision);
-    // this.operators.unshift(operation);
     return this.clone([operation, ...this.operators]);
   }
-  default(fallback: any) {
+  stream(s: LazyCalc): LazyStream {
+    return new LazyStream().add(s);
+  }
+  default(fallback: any): LazyCalc {
     const operation = function(x: number | string) {
       return Number.isNaN(+x) ? fallback : x;
     };
     return this.clone([operation, ...this.operators]);
   }
-  value(fallback: any = 0) {
-    const result = this.compose(this.operators)(this.initValue);
-    this.initValue = 0;
-    return Number.isNaN(result) ? fallback : result;
+  value(): any {
+    return this.compose(this.operators)(this.initValue);
   }
 }
 
-interface ILazyCalc {
-  lazy(init?: number): ILazyCalc;
-  add(number: number): ILazyCalc;
-  subtract(number: number): ILazyCalc;
-  divide(y: number): ILazyCalc;
-  multiply(y: number): ILazyCalc;
-  round(precision?: number): ILazyCalc;
-  floor(precision?: number): ILazyCalc;
-  ceil(precision?: number): ILazyCalc;
-  do(fn: operatorFunc): ILazyCalc;
-  default(fallback: any): ILazyCalc;
-  value(fallback?: any): any;
-}
 export type LzCalcPlugin = {
   install(vue: VueConstructor<Vue>, options?: any): void;
 };
 const instantce: LzCalcPlugin = {
   install(vue, options) {
     let alias = "$lzCalc";
-    const p = new LazyCalc(options) as ILazyCalc;
+    const p = new LazyCalc(options);
     vue.prototype[alias] = p;
     Object.defineProperty(Vue, `${alias}`, {
       get() {
@@ -154,4 +140,3 @@ const instantce: LzCalcPlugin = {
   }
 };
 export default instantce;
-export { ILazyCalc };

src/main.ts

@@ -0,0 +1,42 @@
+import { LazyCalc, operatorFunc } from "./main";
+class LazyStream {
+  private operators: operatorFunc[];
+  private compose = (fns: operatorFunc[]) =>
+    fns.reduceRight(
+      (prevFn: Function, nextFn: Function) => (...args: any[]) =>
+        nextFn(prevFn(...args)),
+      (i: any) => i
+    );
+  private clone(operators: operatorFunc[]) {
+    let tmp = new LazyStream();
+    tmp.operators = operators;
+    return tmp;
+  }
+  constructor() {
+    this.operators = [];
+    return this;
+  }
+
+  add(y: LazyCalc): LazyStream {
+    const operation = function(x: number | string) {
+      const _y = y.value();
+      if (Number.isNaN(+x) || Number.isNaN(+_y)) {
+        return NaN;
+      }
+      return +x + +_y;
+    };
+    return this.clone([operation, ...this.operators]);
+  }
+  default(fallback: any): LazyStream {
+    const operation = function(x: number | string) {
+      return Number.isNaN(+x) ? fallback : +x;
+    };
+    return this.clone([operation, ...this.operators]);
+  }
+
+  value(): any {
+    return this.compose(this.operators)(0);
+  }
+}
+
+export default LazyStream;

src/stream.ts

@@ -1,21 +1,28 @@
 import Vue, { VueConstructor } from "./vue";
+import LazyStream from "./stream";
 export declare type operatorFunc = (i: number | string) => number;
-interface ILazyCalc {
-  lazy(init?: number): ILazyCalc;
-  add(number: number): ILazyCalc;
-  subtract(number: number): ILazyCalc;
-  divide(y: number): ILazyCalc;
-  multiply(y: number): ILazyCalc;
-  round(precision?: number): ILazyCalc;
-  floor(precision?: number): ILazyCalc;
-  ceil(precision?: number): ILazyCalc;
-  do(fn: operatorFunc): ILazyCalc;
-  default(fallback: any): ILazyCalc;
-  value(fallback?: any): any;
+export declare class LazyCalc {
+  initValue: number;
+  operators: operatorFunc[];
+  private compose;
+  private createRound(methodName, precision?);
+  constructor(init?: number);
+  private clone(operators);
+  lazy(init?: number): LazyCalc;
+  add(y: number): LazyCalc;
+  divide(y: number): LazyCalc;
+  subtract(y: number): LazyCalc;
+  multiply(y: number): LazyCalc;
+  do(fn: operatorFunc): LazyCalc;
+  ceil(precision?: number): LazyCalc;
+  floor(precision?: number): LazyCalc;
+  round(precision?: number): LazyCalc;
+  stream(s: LazyCalc): LazyStream;
+  default(fallback: any): LazyCalc;
+  value(): any;
 }
 export declare type LzCalcPlugin = {
   install(vue: VueConstructor<Vue>, options?: any): void;
 };
 declare const instantce: LzCalcPlugin;
 export default instantce;
-export { ILazyCalc };

types/main.d.ts

@@ -0,0 +1,11 @@
+import { LazyCalc } from "./main";
+declare class LazyStream {
+    private operators;
+    private compose;
+    private clone(operators);
+    constructor();
+    add(y: LazyCalc): LazyStream;
+    default(fallback: any): LazyStream;
+    value(): any;
+}
+export default LazyStream;

types/stream.d.ts

@@ -1,17 +1,17 @@
 import Vue, { VueConstructor } from "vue";
-import { ILazyCalc } from "./main";
+import { LazyCalc } from "./main";
 declare module "vue/types/vue" {
   interface Vue {
-    $lzCalc: ILazyCalc;
+    $lzCalc: LazyCalc;
   }
   interface VueConstructor {
-    $lzCalc: ILazyCalc;
+    $lzCalc: LazyCalc;
   }
 }
 
 declare module "vue/types/options" {
   interface ComponentOptions<V extends Vue> {
-    $lzCalc?: ILazyCalc;
+    $lzCalc?: LazyCalc;
   }
 }