@dra2020/baseclient 1.0.82 → 1.0.85

package/dist/csv/csv.d.ts

@@ -1,4 +1,13 @@
 import * as Util from '../util/all';
+export declare class ParseMany {
+    buf: Uint8Array;
+    n: number;
+    one: ParseOne;
+    constructor(coder: Util.Coder, buf: Uint8Array);
+    get length(): number;
+    get fields(): string[];
+    next(): boolean;
+}
 export declare class ParseOne {
     coder: Util.Coder;
     fields: string[];
@@ -12,6 +21,7 @@ export declare class ParseOne {
     force: boolean;
     constructor(coder: Util.Coder, line?: string);
     set(line: string): void;
+    setBuf(buf: Uint8Array): void;
     get length(): number;
     pushtok(): void;
     parse(): void;

package/dist/fsm/fsm.d.ts

@@ -3,6 +3,7 @@ export declare const FSM_STARTING: number;
 export declare const FSM_PENDING: number;
 export declare const FSM_DONE: number;
 export declare const FSM_ERROR: number;
+export declare const FSM_CANCEL: number;
 export declare const FSM_RELEASED: number;
 export declare const FSM_CUSTOM1: number;
 export declare const FSM_CUSTOM2: number;
@@ -44,6 +45,7 @@ export declare class Fsm {
     get ready(): boolean;
     get iserror(): boolean;
     get isDependentError(): boolean;
+    cancel(): void;
     setDependentError(): void;
     clearDependentError(): void;
     get ticked(): boolean;

package/dist/ot-js/otsession.d.ts

@@ -113,6 +113,7 @@ export interface SessionUpdateProps {
     accessUpdate?: AccessMap;
     restore?: string;
     revision?: Revision;
+    colors?: string;
 }
 export interface SessionsIndex {
     [key: string]: SessionProps;

package/docs/fsm.md

@@ -191,14 +191,18 @@ An `Fsm` can be reused and transition from `ready` to not `ready` or `done` to n
 
 ### Cancellation
 
-There is no explicit cancellation mechanism.
+The standard member function `cancel` will set the state to `FSM_CANCEL` which is considered a done state as
+well as an error state (and will set the dependentError flag on any waiting state machines).
 
-By convention, a sub-class should override the `end` member function to allow external cancellation or completion.
-By default this function sets the `Fsm` to `FSM_DONE` but can optionally take the `FSM_ERROR` state
-to indicate error.
+By convention, a sub-class should override the `cancel` member function to allow external cancellation
+if it needs to do more internal cleanup than set the state to `FSM_CANCEL`.
 
-Whether calling `end` or setting the state explicitly to `FSM_DONE` or `FSM_ERROR` from external to
-the state machine makes semantic sense depends on the specific properties and semantics of the computation.
+Additionally, it can use the `end` member function (by convention) to complete the state machine if that
+makes sense and does not wanted to be treated as an error.
+The class should override the `end` member function if it needs to do cleanup and finalization internally.
+
+If a class internally is implemented with callbacks or promises, by convention it should check `if this.done`
+when the callback or promise completes to check whether it may have been externally canceled while awaiting.
 
 ### FsmOnDone
 

package/lib/csv/csv.ts

@@ -23,6 +23,56 @@ function isWhite(c: number): boolean
   return c === Space || c === Newline || c === Tab || c == CR;
 }
 
+// Keep calling next() to retrieve next parsed line. Returns false when done. Empty lines are ignored.
+
+export class ParseMany
+{
+  buf: Uint8Array;
+  n: number;
+  one: ParseOne;
+
+  constructor(coder: Util.Coder, buf: Uint8Array)
+  {
+    this.buf = buf;
+    this.n = 0;
+    this.one = new ParseOne(coder);
+  }
+
+  get length(): number { return this.one.length }
+  get fields(): string[] { return this.one.fields }
+
+  next(): boolean
+  {
+    // Move past any leading CRLF
+    while (this.n < this.buf.length)
+    {
+      let c = this.buf[this.n];
+      if (c == CR || c == Newline)
+        this.n++;
+      else
+        break;
+    }
+
+    let s = this.n;
+    while (this.n < this.buf.length)
+    {
+      let c = this.buf[this.n];
+      if (c == CR || c == Newline)
+        break;
+      else
+        this.n++;
+    }
+
+    if (s != this.n)
+    {
+      this.one.setBuf(this.buf.subarray(s, this.n));
+      return true;
+    }
+    else
+      return false;
+  }
+}
+
 export class ParseOne
 {
   coder: Util.Coder;
@@ -47,9 +97,15 @@ export class ParseOne
 
   set(line: string): void
   {
+    this.setBuf(Util.s2u8(this.coder, line));
+  }
+
+  setBuf(buf: Uint8Array): void
+  {
+    this.buf = buf;
     this.fields = [];
-    this.buf = Util.s2u8(this.coder, line);
-    this.tok = new Uint8Array(new ArrayBuffer(this.buf.length));
+    if (!this.tok || this.tok.length < this.buf.length)
+      this.tok = new Uint8Array(new ArrayBuffer(this.buf.length));
     this.n = 0;
     this.toklen = 0;
     this.infield = false;

package/lib/fsm/fsm.ts

@@ -1,11 +1,12 @@
 // Shared libraries
 import * as Util from '../util/all';
 
-// States
+// States (note these are no longer bit flags - most uses create custom values incrementally from CUSTOM1)
 export const FSM_STARTING: number = 0;
 export const FSM_PENDING: number  = 1<<0;
 export const FSM_DONE: number     = 1<<1;
 export const FSM_ERROR: number    = 1<<2;
+export const FSM_CANCEL: number   = 5;
 export const FSM_RELEASED: number = 1<<3;
 export const FSM_CUSTOM1: number  = 1<<4;
 export const FSM_CUSTOM2: number  = 1<<5;
@@ -22,7 +23,7 @@ let doLater: any = global && global.setImmediate ? setImmediate : (cb: any) => {
 
 function FsmDone(s: number): boolean
 {
-  return (s === FSM_DONE || s === FSM_ERROR || s === FSM_RELEASED);
+  return (s === FSM_DONE || s === FSM_ERROR || s === FSM_RELEASED || s === FSM_CANCEL);
 }
 
 function FsmStateToString(state: number): string
@@ -151,7 +152,7 @@ export class Fsm
 
   get iserror(): boolean
     {
-      return (this.state === FSM_ERROR);
+      return (this.state === FSM_ERROR || this.state === FSM_CANCEL);
     }
 
   get isDependentError(): boolean
@@ -159,6 +160,12 @@ export class Fsm
       return this.dependentError;
     }
 
+  cancel(): void
+    {
+      // Override if you need to do more than marking complete
+      this.setState(FSM_CANCEL);
+    }
+
   setDependentError(): void
     {
       this.dependentError = true;

package/lib/ot-js/otsession.ts

@@ -120,7 +120,7 @@ export interface SessionProps
   xprops?: { [prop: string]: string };
   groups: any;  // DT.GroupsMapIndex
   xid?: string; // external ID
-  colors?: string; // cached district colors (specific to OT redistricting)
+  colors?: string; // cached district colors (specific to OT for redistricting)
 }
 
 // True to add, False to remove
@@ -141,6 +141,7 @@ export interface SessionUpdateProps
   accessUpdate?: AccessMap;
   restore?: string; // Revision ID
   revision?: Revision;  // If ID is empty, snap a new revision, otherwise label it.
+  colors?: string; // cached district colors (specific to OT for redistricting)
 }
 
 export interface SessionsIndex

package/package.json

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