@dra2020/baseclient 1.0.71 → 1.0.75

package/dist/dataflow/all.d.ts

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

package/dist/dataflow/dataflow.d.ts

@@ -0,0 +1,23 @@
+interface UseItem {
+    df: DataFlow;
+    id?: any;
+}
+export declare class DataFlow {
+    usesList: UseItem[];
+    constructor();
+    id(): any;
+    value(): any;
+    uses(df: DataFlow): void;
+    usesStale(): boolean;
+    usesRemember(): void;
+    ifcompute(): void;
+    compute(): void;
+}
+export declare class DataFlowCallback extends DataFlow {
+    _value: any;
+    _cb: () => any;
+    constructor(cb: () => any);
+    id(): any;
+    value(): 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/csv/csv.ts

@@ -87,6 +87,10 @@ export class ParseOne
         this.quote = 0;
         this.nwhite = 0;
       }
+      else if (this.quote)
+      {
+        this.tok[this.toklen++] = c;
+      }
       else if (c === Comma || c === Pipe)
       {
         this.force = true;

package/lib/dataflow/all.ts

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

package/lib/dataflow/dataflow.ts

@@ -0,0 +1,81 @@
+//
+// 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.
+//
+//
+
+interface UseItem
+{
+  df: DataFlow,
+  id?: any,
+}
+
+export class DataFlow
+{
+  usesList: UseItem[];
+
+  constructor()
+  {
+    this.usesList = [];
+  }
+
+  // override in subclass
+  id(): any { return null }
+  value(): any { return null }
+
+  uses(df: DataFlow): void
+  {
+    this.usesList.push({ df: df });
+  }
+
+  usesStale(): boolean
+  {
+    let isstale = false;
+    this.usesList.forEach(ui => { if (ui.id !== ui.df.id()) isstale = true });
+    return isstale;
+  }
+
+  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 }
+  value(): any { return this.id() }
+}

package/package.json

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