@dra2020/baseclient 1.0.72 → 1.0.73

package/dist/all/all.d.ts

@@ -24,3 +24,5 @@ import * as CSV from '../csv/all';
 export { CSV };
 import * as Colors from '../colors/colors';
 export { Colors };
+import * as DataFlow from '../dataflow/all';
+export { DataFlow };

package/dist/baseclient.js

@@ -39,7 +39,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Colors = exports.CSV = exports.Emit = exports.G = exports.FilterExpr = exports.OTE = exports.OT = exports.LogClient = exports.LogAbstract = exports.Poly = exports.FSM = exports.Context = exports.Util = void 0;
+exports.DataFlow = exports.Colors = exports.CSV = exports.Emit = exports.G = exports.FilterExpr = exports.OTE = exports.OT = exports.LogClient = exports.LogAbstract = exports.Poly = exports.FSM = exports.Context = exports.Util = void 0;
 // Client and Server
 const Util = __importStar(__webpack_require__(/*! ../util/all */ "./lib/util/all.ts"));
 exports.Util = Util;
@@ -67,6 +67,8 @@ const CSV = __importStar(__webpack_require__(/*! ../csv/all */ "./lib/csv/all.ts
 exports.CSV = CSV;
 const Colors = __importStar(__webpack_require__(/*! ../colors/colors */ "./lib/colors/colors.ts"));
 exports.Colors = Colors;
+const DataFlow = __importStar(__webpack_require__(/*! ../dataflow/all */ "./lib/dataflow/all.ts"));
+exports.DataFlow = DataFlow;
 
 
 /***/ }),
@@ -978,6 +980,117 @@ class ParseOne {
 exports.ParseOne = ParseOne;
 
 
+/***/ }),
+
+/***/ "./lib/dataflow/all.ts":
+/*!*****************************!*\
+  !*** ./lib/dataflow/all.ts ***!
+  \*****************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+__exportStar(__webpack_require__(/*! ./dataflow */ "./lib/dataflow/dataflow.ts"), exports);
+
+
+/***/ }),
+
+/***/ "./lib/dataflow/dataflow.ts":
+/*!**********************************!*\
+  !*** ./lib/dataflow/dataflow.ts ***!
+  \**********************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+
+//
+// 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.
+//    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.
+//
+//
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.DataFlowNonNull = exports.DataFlow = void 0;
+class DataFlow {
+    constructor() {
+        this.usesList = {};
+        this.uniquename = 1;
+    }
+    // override in subclass
+    ready() { return this.usesReady(); }
+    id() { return null; }
+    value() { return null; }
+    uses(df, name) {
+        if (!name)
+            name = `_df_${this.uniquename++}`;
+        this.usesList[name] = { name: name, df: df };
+    }
+    find(name) {
+        let ui = this.usesList[name];
+        return ui ? ui.df : undefined;
+    }
+    findValue(name) {
+        let df = this.find(name);
+        return df ? df.value() : undefined;
+    }
+    usesReady() {
+        let isready = true;
+        Object.values(this.usesList).forEach((ui) => { if (!ui.df.ready())
+            isready = false; });
+        return isready;
+    }
+    usesStale() {
+        let isstale = false;
+        Object.values(this.usesList).forEach((ui) => { if (ui.df.id !== ui.df.id())
+            isstale = true; });
+        return isstale;
+    }
+    usesRemember() {
+        Object.values(this.usesList).forEach((ui) => { ui.df.id = ui.df.id(); });
+    }
+}
+exports.DataFlow = DataFlow;
+// Takes callback that, when ready, returns non-null. The return value is both the value and the id.
+class DataFlowNonNull extends DataFlow {
+    constructor(cb) {
+        super();
+        this._cb = cb;
+    }
+    ready() {
+        // Allow chaining
+        if (!this.usesReady())
+            return false;
+        // Real core semantics, with chaining on stale
+        if (!this._value || this.usesStale()) {
+            this._value = this._cb();
+            if (this._value)
+                this.usesRemember();
+        }
+        return !!this._value;
+    }
+    id() { return this.ready(), this._value; }
+    value() { return this.ready(), this._value; }
+}
+exports.DataFlowNonNull = DataFlowNonNull;
+
+
 /***/ }),
 
 /***/ "./lib/emit/all.ts":