pondjs - npm Package Compare versions

Comparing version 1.0.0-alpha.1 to 1.0.0-alpha.2

lib/rate.d.ts

@@ -48,5 +48,6 @@ /**
     /**
-     * Perform the `fill` operation on the `Event` and emit.
+     * Perform the rate operation on the `Event` and the the `_previous`
+     * `Event` and emit the result.
      */
     addEvent(event: Event<T>): Immutable.List<Event<TimeRange>>;
 }

lib/rate.js

@@ -83,3 +83,4 @@ "use strict";
     /**
-     * Perform the `fill` operation on the `Event` and emit.
+     * Perform the rate operation on the `Event` and the the `_previous`
+     * `Event` and emit the result.
      */
@@ -101,2 +102,2 @@ addEvent(event) {
 exports.Rate = Rate;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9yYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7Ozs7R0FRRzs7QUFFSCx1Q0FBdUM7QUFDdkMsNEJBQTRCO0FBRTVCLG1DQUFnQztBQUloQywyQ0FBd0M7QUFFeEMsMkNBQW1EO0FBQ25ELGlDQUEwQjtBQUkxQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FvQkc7QUFDSCxVQUFpQyxTQUFRLHFCQUF1QjtJQU81RCxZQUFZLE9BQW9CO1FBQzVCLEtBQUssRUFBRSxDQUFDO1FBQ1IsTUFBTSxFQUFFLFNBQVMsRUFBRSxhQUFhLEdBQUcsS0FBSyxFQUFFLEdBQUcsT0FBTyxDQUFDO1FBRXJELFVBQVU7UUFDVixJQUFJLENBQUMsVUFBVSxHQUFHLENBQUMsQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztRQUNsRSxJQUFJLENBQUMsY0FBYyxHQUFHLGFBQWEsQ0FBQztRQUVwQyxpQkFBaUI7UUFDakIsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUM7SUFDMUIsQ0FBQztJQUVEOzs7T0FHRztJQUNILE9BQU8sQ0FBQyxLQUFLO1FBQ1QsSUFBSSxDQUFDLEdBQUcsU0FBUyxDQUFDLEdBQUcsRUFBZSxDQUFDO1FBRXJDLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxFQUFFLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDMUQsTUFBTSxXQUFXLEdBQUcsS0FBSyxDQUFDLFNBQVMsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2hELE1BQU0sU0FBUyxHQUFHLENBQUMsV0FBVyxHQUFHLFlBQVksQ0FBQyxHQUFHLElBQUksQ0FBQztRQUV0RCxJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRTtZQUMzQixNQUFNLFNBQVMsR0FBRyxjQUFJLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQzFDLE1BQU0sUUFBUSxHQUFHLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNuQyxRQUFRLENBQUMsUUFBUSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsSUFBSSxPQUFPLENBQUM7WUFFekMsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLENBQUM7WUFDbEQsTUFBTSxVQUFVLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUV4QyxJQUFJLElBQUksR0FBRyxJQUFJLENBQUM7WUFDaEIsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUM7Z0JBQ3RELDJCQUEyQjtnQkFDM0IsT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLFNBQVMsaURBQWlELENBQUMsQ0FBQztZQUNyRixDQUFDO1lBQUMsSUFBSSxDQUFDLENBQUM7Z0JBQ0osSUFBSSxHQUFHLENBQUMsVUFBVSxHQUFHLFdBQVcsQ0FBQyxHQUFHLFNBQVMsQ0FBQztZQUNsRCxDQUFDO1lBRUQsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLGNBQWMsS0FBSyxLQUFLLElBQUksSUFBSSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUM7Z0JBQzVDLHNEQUFzRDtnQkFDdEQsQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDO1lBQ2hDLENBQUM7WUFBQyxJQUFJLENBQUMsQ0FBQztnQkFDSixDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLENBQUM7WUFDaEMsQ0FBQztRQUNMLENBQUMsQ0FBQyxDQUFDO1FBRUgsTUFBTSxDQUFDLElBQUksYUFBSyxDQUFDLHFCQUFTLENBQUMsWUFBWSxFQUFFLFdBQVcsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQzlELENBQUM7SUFFRDs7T0FFRztJQUNILFFBQVEsQ0FBQyxLQUFlO1FBQ3BCLE1BQU0sU0FBUyxHQUFHLElBQUksS0FBSyxFQUFvQixDQUFDO1FBRWhELEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7WUFDbEIsSUFBSSxDQUFDLFNBQVMsR0FBRyxLQUFLLENBQUM7WUFDdkIsTUFBTSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQW9CLENBQUM7UUFDOUMsQ0FBQztRQUVELE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDakMsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztZQUNQLFNBQVMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDekIsQ0FBQztRQUVELElBQUksQ0FBQyxTQUFTLEdBQUcsS0FBSyxDQUFDO1FBRXZCLE1BQU0sQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3JDLENBQUM7Q0FDSjtBQTdFRCxvQkE2RUMifQ==
+//# sourceMappingURL=data:application/json;base64,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

lib/stream.d.ts

@@ -9,3 +9,3 @@ import * as Immutable from "immutable";
 import { TimeRange } from "./timerange";
-import { AggregationSpec, AlignmentOptions, CollapseOptions, FillOptions, RateOptions, SelectOptions, WindowingOptions } from "./types";
+import { AggregationSpec, AlignmentOptions, CoalesceOptions, CollapseOptions, FillOptions, RateOptions, ReduceOptions, SelectOptions, WindowingOptions } from "./types";
 /**
@@ -71,2 +71,7 @@ * A Node is a transformation between type S and type T. Both S
     /**
+     * Reduces a sequence of past Event<T>s in the stream to a single output Event<M>.
+     */
+    reduce<M extends Key>(options: ReduceOptions<T>): EventStream<T, U>;
+    coalesce(options: CoalesceOptions): EventStream<T, U>;
+    /**
      * Fill missing values in stream events.
@@ -234,3 +239,3 @@ *
      */
-    addEvent(event: Event<U>): void;
+    addEvent(e: Event<U>): void;
     /**
@@ -292,12 +297,16 @@ * An output, specified as an `KeyedCollectionCallback`, essentially
 /**
- * Processing of incoming `Event` streams to for real time processing.
+ * `Stream` and its associated objects are designed for processing of incoming
+ * `Event` streams at real time. This is useful for live dashboard situations or
+ * possibly real time monitoring and alerting from event streams.
  *
  * Supports remapping, filtering, windowing and aggregation. It is designed for
- * relatively light weight handling of incoming events.
+ * relatively light weight handling of incoming events. Any distribution of
+ * incoming events to different streams should be handled by the user. Typically
+ * you would separate streams based on some incoming criteria.
  *
  * A `Stream` object manages a chain of processing nodes, each type of which
  * provides an appropiate interface. When a `Stream` is initially created with
- * the `stream()` factory function the interface you will be returned in an
- * `EventStream`. If you perform a windowing operation you will be exposed to
- * `KeyedCollectionStream`. While if you aggregate a `KeyedCollectionStream` you
+ * the `stream()` factory function the interface exposed is an `EventStream`.
+ * If you perform a windowing operation you will be exposed to a
+ * `KeyedCollectionStream`. If you aggregate a `KeyedCollectionStream` you
  * will be back to an `EventStream` and so on.
@@ -317,3 +326,3 @@ *
  * ---
- * Example:
+ * Examples:
  *
@@ -351,2 +360,62 @@ * ```typescript
  * ```
+ *
+ * If you have multiple sources you can feed them into the same stream and combine them
+ * with the `coalese()` processor. In this example two event sources are fed into the
+ * `Stream`. One contains `Event`s with just a field "in", and the other just a field
+ * "out". The resulting output is `Event`s with the latest (in arrival time) value for
+ * "in" and "out" together:
+ *
+ * ```typescript
+ * const source = stream()
+ *     .coalesce({ fields: ["in", "out"] })
+ *     .output((e: Event) => results.push(e));
+ *
+ * // Stream events
+ * for (let i = 0; i < 5; i++) {
+ *     source.addEvent(streamIn[i]);  // from stream 1
+ *     source.addEvent(streamOut[i]); // from stream 2
+ * }
+ * ```
+ *
+ * You can do generalized reduce operations where you supply a function that
+ * is provided with the last n points (defaults to 1) and the previous result
+ * which is an `Event`. You will return the next result, and `Event`.
+ *
+ * You could use this to produce a running total:
+ *
+ * ```
+ * const source = stream()
+ *     .reduce({
+ *         count: 1,
+ *         accumulator: event(time(), Immutable.Map({ total: 0 })),
+ *         iteratee(accum, eventList) {
+ *             const current = eventList.get(0);
+ *             const total = accum.get("total") + current.get("count");
+ *             return event(time(current.timestamp()), Immutable.Map({ total }));
+ *         }
+ *     })
+ *     .output((e: Event) => console.log("Running total:", e.toString()) );
+ *
+ * // Add Events into the source...
+ * events.forEach(e => source.addEvent(e));
+ * ```
+ *
+ * Or produce a rolling average:
+ * ```
+ * const source = stream()
+ *     .reduce({
+ *         count: 5,
+ *         iteratee(accum, eventList) {
+ *             const values = eventList.map(e => e.get("value")).toJS();
+ *             return event(
+ *                 time(eventList.last().timestamp()),
+ *                 Immutable.Map({ avg: avg()(values) })
+ *             );
+ *          }
+ *     })
+ *     .output((e: Event) => console.log("Rolling average:", e.toString()) );
+ *
+ * // Add Events into the source...
+ * events.forEach(e => source.addEvent(e));
+ * ```
  */
@@ -353,0 +422,0 @@ export declare class Stream<U extends Key = Time> {

lib/stream.js

@@ -20,2 +20,3 @@ "use strict";
 const rate_1 = require("./rate");
+const reduce_1 = require("./reduce");
 const select_1 = require("./select");
@@ -199,17 +200,2 @@ const windowedcollection_1 = require("./windowedcollection");
 }
-// /**
-//  * @private
-//  *
-//  */
-// // tslint:disable-next-line:max-classes-per-file
-// class ReduceNode<T extends Key> extends Node<Event<T>, Event<T>> {
-//     private processor: Reduce<T>;
-//     constructor(options: ReduceOptions) {
-//         super();
-//         this.processor = new Reduce<T>(options);
-//     }
-//     process(e: Event<T>) {
-//         return this.processor.addEvent(e);
-//     }
-// }
 /**
@@ -220,2 +206,16 @@ * @private
 // tslint:disable-next-line:max-classes-per-file
+class ReduceNode extends Node {
+    constructor(options) {
+        super();
+        this.processor = new reduce_1.Reducer(options);
+    }
+    process(e) {
+        return this.processor.addEvent(e);
+    }
+}
+/**
+ * @private
+ *
+ */
+// tslint:disable-next-line:max-classes-per-file
 class WindowOutputNode extends Node {
@@ -298,2 +298,29 @@ constructor(options) {
     /**
+     * Reduces a sequence of past Event<T>s in the stream to a single output Event<M>.
+     */
+    reduce(options) {
+        return this.stream.addEventMappingNode(new ReduceNode(options));
+    }
+    coalesce(options) {
+        const { fields } = options;
+        function keyIn(...keys) {
+            const keySet = Immutable.Set(...keys);
+            return (v, k) => {
+                return keySet.has(k);
+            };
+        }
+        return this.stream.addEventMappingNode(new ReduceNode({
+            count: 1,
+            iteratee(accum, eventList) {
+                const currentEvent = eventList.get(0);
+                const currentKey = currentEvent.getKey();
+                const accumulatedEvent = !_.isNull(accum)
+                    ? accum
+                    : event_1.event(currentKey, Immutable.Map({}));
+                const filteredData = currentEvent.getData().filter(keyIn(fields));
+                return event_1.event(currentKey, accumulatedEvent.getData().merge(filteredData));
+            }
+        }));
+    }
+    /**
      * Fill missing values in stream events.
@@ -478,4 +505,4 @@ *
      */
-    addEvent(event) {
-        this.stream.addEvent(event);
+    addEvent(e) {
+        this.stream.addEvent(e);
     }
@@ -542,12 +569,16 @@ /**
 /**
- * Processing of incoming `Event` streams to for real time processing.
+ * `Stream` and its associated objects are designed for processing of incoming
+ * `Event` streams at real time. This is useful for live dashboard situations or
+ * possibly real time monitoring and alerting from event streams.
  *
  * Supports remapping, filtering, windowing and aggregation. It is designed for
- * relatively light weight handling of incoming events.
+ * relatively light weight handling of incoming events. Any distribution of
+ * incoming events to different streams should be handled by the user. Typically
+ * you would separate streams based on some incoming criteria.
  *
  * A `Stream` object manages a chain of processing nodes, each type of which
  * provides an appropiate interface. When a `Stream` is initially created with
- * the `stream()` factory function the interface you will be returned in an
- * `EventStream`. If you perform a windowing operation you will be exposed to
- * `KeyedCollectionStream`. While if you aggregate a `KeyedCollectionStream` you
+ * the `stream()` factory function the interface exposed is an `EventStream`.
+ * If you perform a windowing operation you will be exposed to a
+ * `KeyedCollectionStream`. If you aggregate a `KeyedCollectionStream` you
  * will be back to an `EventStream` and so on.
@@ -567,3 +598,3 @@ *
  * ---
- * Example:
+ * Examples:
  *
@@ -601,2 +632,62 @@ * ```typescript
  * ```
+ *
+ * If you have multiple sources you can feed them into the same stream and combine them
+ * with the `coalese()` processor. In this example two event sources are fed into the
+ * `Stream`. One contains `Event`s with just a field "in", and the other just a field
+ * "out". The resulting output is `Event`s with the latest (in arrival time) value for
+ * "in" and "out" together:
+ *
+ * ```typescript
+ * const source = stream()
+ *     .coalesce({ fields: ["in", "out"] })
+ *     .output((e: Event) => results.push(e));
+ *
+ * // Stream events
+ * for (let i = 0; i < 5; i++) {
+ *     source.addEvent(streamIn[i]);  // from stream 1
+ *     source.addEvent(streamOut[i]); // from stream 2
+ * }
+ * ```
+ *
+ * You can do generalized reduce operations where you supply a function that
+ * is provided with the last n points (defaults to 1) and the previous result
+ * which is an `Event`. You will return the next result, and `Event`.
+ *
+ * You could use this to produce a running total:
+ *
+ * ```
+ * const source = stream()
+ *     .reduce({
+ *         count: 1,
+ *         accumulator: event(time(), Immutable.Map({ total: 0 })),
+ *         iteratee(accum, eventList) {
+ *             const current = eventList.get(0);
+ *             const total = accum.get("total") + current.get("count");
+ *             return event(time(current.timestamp()), Immutable.Map({ total }));
+ *         }
+ *     })
+ *     .output((e: Event) => console.log("Running total:", e.toString()) );
+ *
+ * // Add Events into the source...
+ * events.forEach(e => source.addEvent(e));
+ * ```
+ *
+ * Or produce a rolling average:
+ * ```
+ * const source = stream()
+ *     .reduce({
+ *         count: 5,
+ *         iteratee(accum, eventList) {
+ *             const values = eventList.map(e => e.get("value")).toJS();
+ *             return event(
+ *                 time(eventList.last().timestamp()),
+ *                 Immutable.Map({ avg: avg()(values) })
+ *             );
+ *          }
+ *     })
+ *     .output((e: Event) => console.log("Rolling average:", e.toString()) );
+ *
+ * // Add Events into the source...
+ * events.forEach(e => source.addEvent(e));
+ * ```
  */
@@ -660,2 +751,2 @@ // tslint:disable-next-line:max-classes-per-file
 exports.stream = streamFactory;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stream.js","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stream.js","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"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"}

lib/timerange.d.ts

@@ -35,7 +35,7 @@ import * as Immutable from "immutable";
      *   - An `Immutable.List` containing two Dates.
-     *   - A Javascript array containing two `Date` or `ms` timestamps
-     *   - Two arguments, begin and end, each of which may be a `Date`,
-     *     a `Moment`, or a `ms` timestamp.
+     *   - A Javascript array containing two millisecond timestamps
+     *   - Two arguments, `begin` and `end`, each of which may be a `Date`,
+     *     a `Moment`, or a millisecond timestamp.
      */
-    constructor(arg: TimeRange | Immutable.List<Date>);
+    constructor(arg: TimeRange | Immutable.List<Date> | number[]);
     constructor(begin: Date, end: Date);
@@ -156,3 +156,3 @@ constructor(begin: Time, end: Time);
  */
-declare function timerange(arg: TimeRange | Immutable.List<Date>): any;
+declare function timerange(arg: TimeRange | Immutable.List<Date> | number[]): any;
 declare function timerange(begin: Date, end: Date): any;
@@ -159,0 +159,0 @@ declare function timerange(begin: Time, end: Time): any;

lib/timerange.js

@@ -48,2 +48,6 @@ "use strict";
         }
+        else if (arg1 instanceof Array) {
+            const rangeArray = arg1;
+            this._range = Immutable.List([new Date(rangeArray[0]), new Date(rangeArray[1])]);
+        }
         else {
@@ -249,2 +253,2 @@ const b = arg1;
 exports.timerange = timerange;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timerange.js","sourceRoot":"","sources":["../src/timerange.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timerange.js","sourceRoot":"","sources":["../src/timerange.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;AAEH,uCAAuC;AACvC,4BAA4B;AAC5B,iCAAiC;AAGjC,+BAA4B;AAE5B,iCAA8B;AAE9B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAuB,SAAQ,SAAG;IAmB9B,YAAY,IAAS,EAAE,IAAU;QAC7B,KAAK,EAAE,CAAC;QACR,EAAE,CAAC,CAAC,IAAI,YAAY,SAAS,CAAC,CAAC,CAAC;YAC5B,MAAM,KAAK,GAAG,IAAI,CAAC;YACnB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QAC/B,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;YACxC,MAAM,SAAS,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QAC5B,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,YAAY,KAAK,CAAC,CAAC,CAAC;YAC/B,MAAM,UAAU,GAAG,IAAI,CAAC;YACxB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACrF,CAAC;QAAC,IAAI,CAAC,CAAC;YACJ,MAAM,CAAC,GAAG,IAAI,CAAC;YACf,MAAM,CAAC,GAAG,IAAI,CAAC;YACf,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC7B,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;YACjF,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAClD,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;YACjF,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,WAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,WAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC1C,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;YACjF,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACxC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC7D,CAAC;QACL,CAAC;IACL,CAAC;IAED,IAAI;QACA,MAAM,CAAC,WAAW,CAAC;IACvB,CAAC;IAED;;;OAGG;IACH,QAAQ;QACJ,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED;;;OAGG;IACH,MAAM;QACF,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC;IACzE,CAAC;IAED;;;;OAIG;IACH,QAAQ;QACJ,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,aAAa;QACT,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE,KAAK,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,WAAW;QACP,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,WAAW,EAAE,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,GAAG,CAAC;IAC1E,CAAC;IAED;;;OAGG;IACH,QAAQ;QACJ,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QACnC,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;QAC/B,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,wBAAwB,CAAC,CAAC;QACxD,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,wBAAwB,CAAC,CAAC;QACpD,MAAM,CAAC,GAAG,QAAQ,OAAO,MAAM,EAAE,CAAC;IACtC,CAAC;IAED;;;;OAIG;IACH,cAAc;QACV,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QACnC,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,KAAK;QACD,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,GAAG;QACC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,GAAG;QACC,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvD,CAAC;IAED;;;OAGG;IACH,SAAS;QACL,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,CAAO;QACZ,MAAM,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,CAAO;QACV,MAAM,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAgB;QACnB,MAAM,CAAC,CACH,IAAI,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,KAAK,KAAK,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE;YAClD,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,KAAK,KAAK,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CACjD,CAAC;IACN,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAuB;QAC5B,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAClB,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,KAAK,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,KAAK,CAAC;QACxD,CAAC;QAAC,IAAI,CAAC,CAAC;YACJ,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,KAAK,CAAC,KAAK,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,KAAK,CAAC,GAAG,EAAE,CAAC;QACtE,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,KAAgB;QACnB,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,KAAK,CAAC,KAAK,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,KAAK,CAAC,GAAG,EAAE,CAAC;IACtE,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAgB;QACrB,EAAE,CAAC,CACC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;YAC7D,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAChE,CAAC,CAAC,CAAC;YACC,MAAM,CAAC,IAAI,CAAC;QAChB,CAAC;QAAC,IAAI,CAAC,CAAC;YACJ,MAAM,CAAC,KAAK,CAAC;QACjB,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,KAAgB;QACrB,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,KAAK,EAAE,IAAI,IAAI,CAAC,KAAK,EAAE,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC;IACpE,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,KAAgB;QACpB,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACtE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QAC9D,MAAM,CAAC,IAAI,SAAS,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACvE,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,KAAgB;QACzB,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACvB,MAAM,CAAC;QACX,CAAC;QACD,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACtE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QAC9D,MAAM,CAAC,IAAI,SAAS,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACvE,CAAC;IAED;;OAEG;IACH,QAAQ;QACJ,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC;IACzD,CAAC;IAED;;OAEG;IACH,gBAAgB;QACZ,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;IACvD,CAAC;CACJ;AAtPD,8BAsPC;AAWD,mBAAmB,IAAS,EAAE,IAAU;IACpC,MAAM,CAAC,IAAI,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AACrC,CAAC;AAEQ,8BAAS"}

lib/types.d.ts

@@ -62,2 +62,35 @@ import * as Immutable from "immutable";
 /**
+ * Options object expected by the `reduce()` stream processor. The idea
+ * of this processor is to take a list of Events, always of size `count`
+ * (default is 1),
+ * e.g.
+ * ```
+ * {
+ *     count: 1,
+ *     accumulator: event(time(), Immutable.Map({ total: 0 })),
+ *     iteratee(accum, eventList) {
+ *         const current = eventList.get(0);
+ *         const total = accum.get("total") + current.get("count");
+ *         return event(time(current.timestamp()), Immutable.Map({ total }));
+ *     }
+ * }
+ * ```
+ *  * count - The number of `Event`s to include on each call
+ *  * reducer - a function mapping an `Immutable.List<Event>` to an `Event`
+ *  * accumulator - an optional `Event` initial value
+ */
+export interface ReduceOptions<K extends Key> {
+    count: number;
+    accumulator?: Event<K>;
+    iteratee: ListReducer<K>;
+}
+/**
+ * Options object expected by the `coalesce()` stream processor. This
+ * will take the latest of each field in `fields` and combine that into
+ * a new `Event`.
+ */
+export interface CoalesceOptions {
+    fields: string[];
+}
+/**
  * Options object expected by the `windowBy...()` functions. At this point,
@@ -166,3 +199,3 @@ * this just defines the fixed window (e.g. window: period("1d")) and the
     seriesList: Array<TimeSeries<Key>>;
-    reducer?: ReducerFunction | ArrayReducer | ListReducer;
+    reducer?: ReducerFunction | ArrayMapper | ListMapper;
     fieldSpec?: string | string[];
@@ -185,10 +218,14 @@ [propName: string]: any;
 /**
- * A function which combines an array of events into a new array of events
+ * A function which combines an Array<Event<Key>> into a new Array<Event<Key>>
  */
-export declare type ArrayReducer = (events: Array<Event<Key>>) => Array<Event<Key>>;
+export declare type ArrayMapper = (events: Array<Event<Key>>) => Array<Event<Key>>;
 /**
- * A function which combines a list of events into a new list of events
+ * A function which combines a list of `Event`s into a new list of `Event`s
  */
-export declare type ListReducer = (events: Immutable.List<Event<Key>>) => Immutable.List<Event<Key>>;
+export declare type ListMapper = (events: Immutable.List<Event<Key>>) => Immutable.List<Event<Key>>;
 /**
+ * A function which combines a `Immutable.List<Event<Key>>` into a single `Event`
+ */
+export declare type ListReducer<T extends Key> = (accum: Event<T>, events: Immutable.List<Event<T>>) => Event<T>;
+/**
  * Tuple mapping a string -> `ReducerFunction`
@@ -195,0 +232,0 @@ * e.g. `["value", avg()]`

package.json

 {
     "name": "pondjs",
-    "version": "1.0.0-alpha.1",
+    "version": "1.0.0-alpha.2",
     "description": "A TimeSeries library built on Immutable.js with Typescript",
@@ -5,0 +5,0 @@ "main": "lib/exports.js",

tests/stream.test.ts

@@ -26,2 +26,16 @@ declare const describe: any;
 
+const streamingEvents = [
+    event(time(0), Immutable.Map({ count: 5, value: 1 })),
+    event(time(30000), Immutable.Map({ count: 3, value: 3 })),
+    event(time(60000), Immutable.Map({ count: 4, value: 10 })),
+    event(time(90000), Immutable.Map({ count: 1, value: 40 })),
+    event(time(120000), Immutable.Map({ count: 5, value: 70 })),
+    event(time(150000), Immutable.Map({ count: 3, value: 130 })),
+    event(time(180000), Immutable.Map({ count: 2, value: 190 })),
+    event(time(210000), Immutable.Map({ count: 6, value: 220 })),
+    event(time(240000), Immutable.Map({ count: 1, value: 300 })),
+    event(time(270000), Immutable.Map({ count: 0, value: 390 })),
+    event(time(300000), Immutable.Map({ count: 2, value: 510 }))
+];
+
 describe("Streaming", () => {
@@ -345,71 +359,89 @@ it("can do streaming of just events", () => {
     });
-});
 
-/*
-    // TODO: Streaming grouping
+    it("can process a running total using the straeam reduce() function", () => {
+        const results = [];
 
-        it("can do streaming aggregation with grouping", () => {
-            const eventsIn = [
-                // tslint:disable:max-line-length
-                event(
-                    time(Date.UTC(2015, 2, 14, 7, 57, 0)),
-                    Immutable.Map({ type: "a", in: 3, out: 1 })
-                ),
-                event(
-                    time(Date.UTC(2015, 2, 14, 7, 58, 0)),
-                    Immutable.Map({ type: "a", in: 9, out: 2 })
-                ),
-                event(
-                    time(Date.UTC(2015, 2, 14, 7, 59, 0)),
-                    Immutable.Map({ type: "b", in: 6, out: 6 })
-                ),
-                event(
-                    time(Date.UTC(2015, 2, 14, 8, 0, 0)),
-                    Immutable.Map({ type: "a", in: 4, out: 7 })
-                ),
-                event(
-                    time(Date.UTC(2015, 2, 14, 8, 1, 0)),
-                    Immutable.Map({ type: "b", in: 5, out: 9 })
-                )
-            ];
+        const source = stream()
+            .reduce({
+                count: 1,
+                accumulator: event(time(), Immutable.Map({ total: 0 })),
+                iteratee(accum, eventList) {
+                    const current = eventList.get(0);
+                    const total = accum.get("total") + current.get("count");
+                    return event(time(current.timestamp()), Immutable.Map({ total }));
+                }
+            })
+            .output((e: Event) => results.push(e));
 
-            let result: Collection<Index>;
+        // Stream events
+        streamingEvents.forEach(e => source.addEvent(e));
 
-            const source = stream()
-                .emitPerEvent()
-                .groupBy("type")
-                .fixedWindow(period("1h"))
-                .aggregate({
-                    type: ["type", keep()],
-                    in_avg: ["in", avg()],
-                    out_avg: ["out", avg()]
-                })
-                .output(collection => {
-                    result = collection as Collection<Index>;
-                });
+        expect(results[0].get("total")).toBe(5);
+        expect(results[5].get("total")).toBe(21);
+        expect(results[10].get("total")).toBe(32);
+    });
 
-            eventsIn.forEach(event => source.addEvent(event));
+    it("can process a rolling average of the last 5 points", () => {
+        const results = [];
 
-            expect(result.at(0).get("type")).toBe("a");
-            expect(result.at(0).get("in_avg")).toBe(6);
-            expect(result.at(0).get("out_avg")).toBe(1.5);
-            expect(result.at(0).getKey().asString()).toBe("1h-396199");
+        const source = stream()
+            .reduce({
+                count: 5,
+                iteratee(accum, eventList) {
+                    const values = eventList.map(e => e.get("value")).toJS();
+                    return event(
+                        time(eventList.last().timestamp()),
+                        Immutable.Map({ avg: avg()(values) })
+                    );
+                }
+            })
+            .output((e: Event) => results.push(e));
 
-            expect(result.at(1).get("type")).toBe("a");
-            expect(result.at(1).get("in_avg")).toBe(4);
-            expect(result.at(1).get("out_avg")).toBe(7);
-            expect(result.at(1).getKey().asString()).toBe("1h-396200");
+        // Stream events
+        streamingEvents.forEach(e => source.addEvent(e));
 
-            expect(result.at(3).get("type")).toBe("b");
-            expect(result.at(2).get("in_avg")).toBe(6);
-            expect(result.at(2).get("out_avg")).toBe(6);
-            expect(result.at(2).getKey().asString()).toBe("1h-396199");
+        expect(results[0].get("avg")).toBe(1);
+        expect(results[5].get("avg")).toBe(50.6);
+        expect(results[10].get("avg")).toBe(322);
+    });
 
-            expect(result.at(3).get("type")).toBe("b");
-            expect(result.at(3).get("in_avg")).toBe(5);
-            expect(result.at(3).get("out_avg")).toBe(9);
-            expect(result.at(3).getKey().asString()).toBe("1h-396200");
-        });
+    it("can coalese two streams", () => {
+        const results = [];
+
+        const streamIn = [
+            event(time(Date.UTC(2015, 2, 14, 1, 15, 0)), Immutable.Map({ in: 1 })),
+            event(time(Date.UTC(2015, 2, 14, 1, 16, 0)), Immutable.Map({ in: 2 })),
+            event(time(Date.UTC(2015, 2, 14, 1, 17, 0)), Immutable.Map({ in: 3 })),
+            event(time(Date.UTC(2015, 2, 14, 1, 18, 0)), Immutable.Map({ in: 4 })),
+            event(time(Date.UTC(2015, 2, 14, 1, 19, 0)), Immutable.Map({ in: 5 }))
+        ];
+
+        const streamOut = [
+            event(time(Date.UTC(2015, 2, 14, 1, 15, 0)), Immutable.Map({ out: 9, count: 2 })),
+            event(time(Date.UTC(2015, 2, 14, 1, 16, 0)), Immutable.Map({ out: 10, count: 3 })),
+            event(time(Date.UTC(2015, 2, 14, 1, 17, 0)), Immutable.Map({ count: 4 })),
+            event(time(Date.UTC(2015, 2, 14, 1, 18, 0)), Immutable.Map({ out: 12, count: 5 })),
+            event(time(Date.UTC(2015, 2, 14, 1, 19, 0)), Immutable.Map({ out: 13, count: 6 }))
+        ];
+
+        const source = stream()
+            .coalesce({
+                fields: ["in", "out"]
+            })
+            .output((e: Event) => results.push(e));
+
+        // Stream events
+        for (let i = 0; i < 5; i++) {
+            source.addEvent(streamIn[i]);
+            source.addEvent(streamOut[i]);
+        }
+
+        expect(results.length).toBe(10);
+        expect(results[5].get("in")).toBe(3);
+        expect(results[5].get("out")).toBe(10);
+        expect(results[8].get("in")).toBe(5);
+        expect(results[8].get("out")).toBe(12);
+        expect(results[9].get("in")).toBe(5);
+        expect(results[9].get("out")).toBe(13);
     });
 });
-*/

tests/timerange.test.ts

@@ -41,2 +41,7 @@ /**
 
+it("can create a new range with two millisecond tiemstamps as an array", () => {
+    const range = timerange([1326309060000, 1329941520000]);
+    expect(range.toJSON()).toEqual({ timerange: [1326309060000, 1329941520000] });
+})
+
 it("can be used to give a new range", () => {
@@ -43,0 +48,0 @@ const beginTime = moment("2012-01-11 1:11", fmt).toDate();

tests/window.test.ts

@@ -55,2 +55,7 @@ declare const describe: any;
 
+    it("can find the index string for a window given a time", () => {
+        const t1 = time(new Date(2017, 11, 19, 12, 0, 0));
+        const hourly = window(duration("1h"));
+    });
+
     it("can use a day window", () => {
@@ -57,0 +62,0 @@ const dayWindowNewYork = daily("America/New_York");

No alert changes

Improved metrics

Total package byte prevSize

1272704

increased by1.31%

Number of package files

84

increased by2.44%

Lines of code

21023

increased by1.63%

No dependency changes