@dra2020/baseclient 1.0.72 → 1.0.76

package/dist/dataflow/all.d.ts

@@ -0,0 +1 @@
+export * from './dataflow';

package/dist/dataflow/dataflow.d.ts

@@ -0,0 +1,24 @@
+interface UseItem {
+    name?: string;
+    df: DataFlow;
+    id?: any;
+    wasstale?: boolean;
+}
+export declare class DataFlow {
+    usesList: UseItem[];
+    constructor();
+    id(): any;
+    uses(df: DataFlow, name?: string): void;
+    usesStale(): boolean;
+    wasStale(name: string): boolean;
+    usesRemember(): void;
+    ifcompute(): void;
+    compute(): void;
+}
+export declare class DataFlowCallback extends DataFlow {
+    _value: any;
+    _cb: () => any;
+    constructor(cb: () => any);
+    id(): any;
+}
+export {};

package/lib/all/all.ts

@@ -25,3 +25,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/lib/dataflow/all.ts

@@ -0,0 +1 @@
+export * from './dataflow';

package/lib/dataflow/dataflow.ts

@@ -0,0 +1,87 @@
+//
+// 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(). 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 "stale" (have changed) the computation
+//       needs to be run.
+//
+//
+
+interface UseItem
+{
+  name?: string;
+  df: DataFlow,
+  id?: any,
+  wasstale?: boolean,
+}
+
+export class DataFlow
+{
+  usesList: UseItem[];
+
+  constructor()
+  {
+    this.usesList = [];
+  }
+
+  // override in subclass
+  id(): any { return null }
+
+  uses(df: DataFlow, name?: string): void
+  {
+    this.usesList.push({ name: name, df: df });
+  }
+
+  usesStale(): boolean
+  {
+    let isstale = false;
+    this.usesList.forEach(ui => {
+        ui.wasstale = ui.id !== ui.df.id();
+        if (ui.wasstale) isstale = true;
+      });
+    return isstale;
+  }
+
+  wasStale(name: string): boolean
+  {
+    let ui: UseItem = this.usesList.find((ui: UseItem) => ui.name === name);
+    return ui != null && ui.wasstale;
+  }
+
+  usesRemember(): void
+  {
+    this.usesList.forEach(ui => { ui.id = ui.df.id() });
+  }
+
+  ifcompute(): void
+  {
+    if (this.usesStale())
+    {
+      this.usesRemember();
+      this.compute();
+    }
+  }
+
+  compute(): void
+  {
+  }
+}
+
+// Takes callback that, eventually, returns non-null. The return value is both the value and the id.
+// Once the value returns non-null, the callback is never called again.
+export class DataFlowCallback extends DataFlow
+{
+  _value: any;
+  _cb: () => any;
+
+  constructor(cb: () => any)
+  {
+    super();
+    this._cb = cb;
+  }
+
+  id(): any { if (!this._value) this._value = this._cb(); return this._value }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dra2020/baseclient",
-  "version": "1.0.72",
+  "version": "1.0.76",
   "description": "Utility functions for Javascript projects.",
   "main": "dist/baseclient.js",
   "types": "./dist/all/all.d.ts",