@dra2020/baseclient 1.0.75 → 1.0.78

package/README.md

@@ -19,6 +19,7 @@ These libraries are used across both client and server:
 - [Poly](./docs/poly.md): A set of functions for processing polygons, typically in GeoJSON format.
 - [Context](./docs/context.md): A set of functions for interrogating the context supplied to the application, either as
 - [FSM](./docs/fsm.md): A set of functions for managing asynchronous, chainable finite state machines.
+- [DataFlow](./docs/dataflow.md): A set of classes for managing synchronous, chainable dataflow.
 - [LogAbstract](./docs/logabstract.md): An abstract logging interface. Different implementations are used on client and server.
 - [LogClient](./docs/logclient.md): A client implementation of the logging abstract interface.
 - [OT](./docs/ot-js.md): An Operational Transformation implementation, used as the basis for all content editing.

package/dist/baseclient.js

@@ -1016,45 +1016,49 @@ __exportStar(__webpack_require__(/*! ./dataflow */ "./lib/dataflow/dataflow.ts")
 // DataFlow: mechanism for setting up a data-flow dependency graph that gets computed on demand.
 //
 //  Semantics are these:
-//    1. The simplest "atomic" DataFlow object just has an id() and a value(). The id() is used to check for exact
-//       equivalence when determining if any dependents need to be recomputed. id() and value() might be the same
-//       for something that just creates a new whole object when recomputed. In other cases, id() might represent a
-//       hash or changestamp/timestamp that is distinct from the value(). The value may or may not be "ready" as well.
-//       If the value is not "ready", no dependents can be computed.
+//    1. The simplest "atomic" DataFlow object just has an id(). The id() is used to check for exact
+//       equivalence when determining if any dependents need to be recomputed.
 //    2. A DataFlow object can record that it "uses" another DataFlow object. If it does, it can use a set of helper
-//       routines to track the state of its dependents. When its dependents are all ready(), it remembers their ids
-//       and can later test if they are stale.
+//       routines to track the state of its dependents. When its dependents are "stale" (have changed) the computation
+//       needs to be run.
 //
 //
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DataFlowCallback = exports.DataFlow = void 0;
+exports.DataFlowStamp = exports.DataFlowCallback = exports.DataFlow = void 0;
 class DataFlow {
     constructor() {
         this.usesList = [];
     }
     // override in subclass
-    id() { return null; }
-    value() { return null; }
-    uses(df) {
-        this.usesList.push({ df: df });
+    dfid() { return null; }
+    // override in subclass
+    compute() {
+    }
+    uses(df, name) {
+        this.usesList.push({ name: name, df: df });
     }
-    usesStale() {
+    stale() {
         let isstale = false;
-        this.usesList.forEach(ui => { if (ui.id !== ui.df.id())
-            isstale = true; });
+        this.usesList.forEach(ui => {
+            ui.wasfresh = ui.id !== ui.df.dfid();
+            if (ui.wasfresh)
+                isstale = true;
+        });
         return isstale;
     }
-    usesRemember() {
-        this.usesList.forEach(ui => { ui.id = ui.df.id(); });
+    wasFresh(name) {
+        let ui = this.usesList.find((ui) => ui.name === name);
+        return ui != null && ui.wasfresh;
+    }
+    remember() {
+        this.usesList.forEach(ui => { ui.id = ui.df.dfid(); });
     }
     ifcompute() {
-        if (this.usesStale()) {
-            this.usesRemember();
+        if (this.stale()) {
+            this.remember();
             this.compute();
         }
     }
-    compute() {
-    }
 }
 exports.DataFlow = DataFlow;
 // Takes callback that, eventually, returns non-null. The return value is both the value and the id.
@@ -1064,11 +1068,20 @@ class DataFlowCallback extends DataFlow {
         super();
         this._cb = cb;
     }
-    id() { if (!this._value)
+    dfid() { if (!this._value)
         this._value = this._cb(); return this._value; }
-    value() { return this.id(); }
 }
 exports.DataFlowCallback = DataFlowCallback;
+// Simple helper that maintains a simple monotonically increasing stamp
+class DataFlowStamp extends DataFlow {
+    constructor() {
+        super();
+        this._stamp = 0;
+    }
+    dfid() { return this._stamp; }
+    stamp() { this._stamp++; }
+}
+exports.DataFlowStamp = DataFlowStamp;
 
 
 /***/ }),